@react-three/fiber 10.0.0-canary.c5c1a94 → 10.0.0-canary.c6846c3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/legacy.mjs CHANGED
@@ -1,20 +1,19 @@
1
1
  import * as three from 'three';
2
- import { WebGLCubeRenderTarget, WebGLRenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene, HalfFloatType, Color, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, Raycaster, OrthographicCamera, PerspectiveCamera, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGLRenderer } from 'three';
2
+ import { WebGLCubeRenderTarget, WebGLRenderTarget, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Raycaster, OrthographicCamera, PerspectiveCamera, Scene, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGLRenderer, HalfFloatType, Color } from 'three';
3
3
  import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
4
4
  import * as React from 'react';
5
- import React__default, { useLayoutEffect, useRef, useMemo, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
5
+ import React__default, { useRef, useMemo, useLayoutEffect, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
6
6
  import useMeasure from 'react-use-measure';
7
7
  import { useFiber, useContextBridge, traverseFiber, FiberProvider } from 'its-fine';
8
- import { useThree as useThree$1, useLoader as useLoader$1, useFrame as useFrame$1, createPortal as createPortal$1, applyProps as applyProps$1, extend as extend$1 } from '@react-three/fiber';
8
+ import { createWithEqualityFn } from 'zustand/traditional';
9
+ import { getScheduler } from '@pmndrs/scheduler';
10
+ export { Scheduler, getScheduler } from '@pmndrs/scheduler';
11
+ import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
9
12
  import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
10
13
  import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
11
14
  import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
12
15
  import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
13
16
  import { GainMapLoader } from '@monogrid/gainmap-js';
14
- import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
15
- import { createWithEqualityFn } from 'zustand/traditional';
16
- import { getScheduler } from '@pmndrs/scheduler';
17
- export { Scheduler, getScheduler } from '@pmndrs/scheduler';
18
17
  import { suspend, preload, clear } from 'suspend-react';
19
18
 
20
19
  function _mergeNamespaces(n, m) {
@@ -114,555 +113,229 @@ function getPrimaryIds() {
114
113
  return Array.from(primaryRegistry.keys());
115
114
  }
116
115
 
117
- const presetsObj = {
118
- apartment: "lebombo_1k.hdr",
119
- city: "potsdamer_platz_1k.hdr",
120
- dawn: "kiara_1_dawn_1k.hdr",
121
- forest: "forest_slope_1k.hdr",
122
- lobby: "st_fagans_interior_1k.hdr",
123
- night: "dikhololo_night_1k.hdr",
124
- park: "rooitou_park_1k.hdr",
125
- studio: "studio_small_03_1k.hdr",
126
- sunset: "venice_sunset_1k.hdr",
127
- warehouse: "empty_warehouse_01_1k.hdr"
128
- };
116
+ var __defProp = Object.defineProperty;
117
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
118
+ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
119
+ const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
120
+ function useMutableCallback(fn) {
121
+ const ref = React.useRef(fn);
122
+ useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
123
+ return ref;
124
+ }
125
+ function useBridge() {
126
+ const fiber = useFiber();
127
+ const ContextBridge = useContextBridge();
128
+ return React.useMemo(
129
+ () => ({ children }) => {
130
+ const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
131
+ const Root = strict ? React.StrictMode : React.Fragment;
132
+ return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
133
+ },
134
+ [fiber, ContextBridge]
135
+ );
136
+ }
137
+ function Block({ set }) {
138
+ useIsomorphicLayoutEffect(() => {
139
+ set(new Promise(() => null));
140
+ return () => set(false);
141
+ }, [set]);
142
+ return null;
143
+ }
144
+ const ErrorBoundary = /* @__PURE__ */ (() => {
145
+ var _a;
146
+ return _a = class extends React.Component {
147
+ constructor() {
148
+ super(...arguments);
149
+ __publicField(this, "state", { error: false });
150
+ }
151
+ componentDidCatch(err) {
152
+ this.props.set(err);
153
+ }
154
+ render() {
155
+ return this.state.error ? null : this.props.children;
156
+ }
157
+ }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
158
+ })();
129
159
 
130
- const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
131
- const isArray = (arr) => Array.isArray(arr);
132
- const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
133
- function useEnvironment({
134
- files = defaultFiles,
135
- path = "",
136
- preset = void 0,
137
- colorSpace = void 0,
138
- extensions
139
- } = {}) {
140
- if (preset) {
141
- validatePreset(preset);
142
- files = presetsObj[preset];
143
- path = CUBEMAP_ROOT;
144
- }
145
- const multiFile = isArray(files);
146
- const { extension, isCubemap } = getExtension(files);
147
- const loader = getLoader$1(extension);
148
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
149
- const renderer = useThree$1((state) => state.renderer);
150
- useLayoutEffect(() => {
151
- if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
152
- function clearGainmapTexture() {
153
- useLoader$1.clear(loader, multiFile ? [files] : files);
160
+ const is = {
161
+ obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
162
+ fun: (a) => typeof a === "function",
163
+ str: (a) => typeof a === "string",
164
+ num: (a) => typeof a === "number",
165
+ boo: (a) => typeof a === "boolean",
166
+ und: (a) => a === void 0,
167
+ nul: (a) => a === null,
168
+ arr: (a) => Array.isArray(a),
169
+ equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
170
+ if (typeof a !== typeof b || !!a !== !!b) return false;
171
+ if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
172
+ const isObj = is.obj(a);
173
+ if (isObj && objects === "reference") return a === b;
174
+ const isArr = is.arr(a);
175
+ if (isArr && arrays === "reference") return a === b;
176
+ if ((isArr || isObj) && a === b) return true;
177
+ let i;
178
+ for (i in a) if (!(i in b)) return false;
179
+ if (isObj && arrays === "shallow" && objects === "shallow") {
180
+ for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
181
+ } else {
182
+ for (i in strict ? b : a) if (a[i] !== b[i]) return false;
154
183
  }
155
- renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
156
- }, [extension, files, loader, multiFile, renderer.domElement]);
157
- const loaderResult = useLoader$1(
158
- loader,
159
- multiFile ? [files] : files,
160
- (loader2) => {
161
- if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
162
- loader2.setRenderer?.(renderer);
163
- }
164
- loader2.setPath?.(path);
165
- if (extensions) extensions(loader2);
184
+ if (is.und(i)) {
185
+ if (isArr && a.length === 0 && b.length === 0) return true;
186
+ if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
187
+ if (a !== b) return false;
166
188
  }
167
- );
168
- let texture = multiFile ? (
169
- // @ts-ignore
170
- loaderResult[0]
171
- ) : loaderResult;
172
- if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
173
- texture = texture.renderTarget?.texture;
174
- }
175
- texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
176
- texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
177
- return texture;
178
- }
179
- const preloadDefaultOptions = {
180
- files: defaultFiles,
181
- path: "",
182
- preset: void 0,
183
- extensions: void 0
184
- };
185
- useEnvironment.preload = (preloadOptions) => {
186
- const options = { ...preloadDefaultOptions, ...preloadOptions };
187
- let { files, path = "" } = options;
188
- const { preset, extensions } = options;
189
- if (preset) {
190
- validatePreset(preset);
191
- files = presetsObj[preset];
192
- path = CUBEMAP_ROOT;
193
- }
194
- const { extension } = getExtension(files);
195
- if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
196
- throw new Error("useEnvironment: Preloading gainmaps is not supported");
197
- }
198
- const loader = getLoader$1(extension);
199
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
200
- useLoader$1.preload(loader, isArray(files) ? [files] : files, (loader2) => {
201
- loader2.setPath?.(path);
202
- if (extensions) extensions(loader2);
203
- });
204
- };
205
- const clearDefaultOptins = {
206
- files: defaultFiles,
207
- preset: void 0
208
- };
209
- useEnvironment.clear = (clearOptions) => {
210
- const options = { ...clearDefaultOptins, ...clearOptions };
211
- let { files } = options;
212
- const { preset } = options;
213
- if (preset) {
214
- validatePreset(preset);
215
- files = presetsObj[preset];
189
+ return true;
216
190
  }
217
- const { extension } = getExtension(files);
218
- const loader = getLoader$1(extension);
219
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
220
- useLoader$1.clear(loader, isArray(files) ? [files] : files);
221
191
  };
222
- function validatePreset(preset) {
223
- if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
192
+ const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
193
+ const isRef$1 = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
194
+ const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
195
+ const isObject3D = (object) => object?.isObject3D;
196
+ const isTexture = (value) => !!value?.isTexture;
197
+ const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
198
+ const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
199
+ const hasConstructor = (object) => !!object?.constructor;
200
+
201
+ function calculateDpr(dpr) {
202
+ const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
203
+ return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
224
204
  }
225
- function getExtension(files) {
226
- const isCubemap = isArray(files) && files.length === 6;
227
- const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
228
- const firstEntry = isArray(files) ? files[0] : files;
229
- const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
230
- return { extension, isCubemap, isGainmap };
205
+ function getUuidPrefix(uuid) {
206
+ return uuid.split("-")[0];
231
207
  }
232
- function getLoader$1(extension) {
233
- const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
234
- return loader;
208
+ function updateCamera(camera, size) {
209
+ if (camera.manual) return;
210
+ if (isOrthographicCamera(camera)) {
211
+ camera.left = size.width / -2;
212
+ camera.right = size.width / 2;
213
+ camera.top = size.height / 2;
214
+ camera.bottom = size.height / -2;
215
+ } else {
216
+ camera.aspect = size.width / size.height;
217
+ }
218
+ camera.updateProjectionMatrix();
235
219
  }
236
-
237
- const isRef$1 = (obj) => obj.current && obj.current.isScene;
238
- const resolveScene = (scene) => isRef$1(scene) ? scene.current : scene;
239
- function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
240
- sceneProps = {
241
- backgroundBlurriness: 0,
242
- backgroundIntensity: 1,
243
- backgroundRotation: [0, 0, 0],
244
- environmentIntensity: 1,
245
- environmentRotation: [0, 0, 0],
246
- ...sceneProps
247
- };
248
- const target = resolveScene(scene || defaultScene);
249
- const oldbg = target.background;
250
- const oldenv = target.environment;
251
- const oldSceneProps = {
252
- // @ts-ignore
253
- backgroundBlurriness: target.backgroundBlurriness,
254
- // @ts-ignore
255
- backgroundIntensity: target.backgroundIntensity,
256
- // @ts-ignore
257
- backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
258
- // @ts-ignore
259
- environmentIntensity: target.environmentIntensity,
260
- // @ts-ignore
261
- environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
262
- };
263
- if (background !== "only") target.environment = texture;
264
- if (background) target.background = texture;
265
- applyProps$1(target, sceneProps);
266
- return () => {
267
- if (background !== "only") target.environment = oldenv;
268
- if (background) target.background = oldbg;
269
- applyProps$1(target, oldSceneProps);
270
- };
220
+ const frustumMatrix = new Matrix4();
221
+ function updateFrustum(camera, frustum) {
222
+ const target = frustum ?? new Frustum();
223
+ frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
224
+ target.setFromProjectionMatrix(frustumMatrix);
225
+ return target;
271
226
  }
272
- function EnvironmentMap({ scene, background = false, map, ...config }) {
273
- const defaultScene = useThree$1((state) => state.scene);
274
- React.useLayoutEffect(() => {
275
- if (map) return setEnvProps(background, scene, defaultScene, map, config);
276
- });
277
- return null;
227
+
228
+ const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
229
+ function findInitialRoot(instance) {
230
+ let root = instance.root;
231
+ while (root.getState().previousRoot) root = root.getState().previousRoot;
232
+ return root;
278
233
  }
279
- function EnvironmentCube({
280
- background = false,
281
- scene,
282
- blur,
283
- backgroundBlurriness,
284
- backgroundIntensity,
285
- backgroundRotation,
286
- environmentIntensity,
287
- environmentRotation,
288
- ...rest
289
- }) {
290
- const texture = useEnvironment(rest);
291
- const defaultScene = useThree$1((state) => state.scene);
292
- React.useLayoutEffect(() => {
293
- return setEnvProps(background, scene, defaultScene, texture, {
294
- backgroundBlurriness: blur ?? backgroundBlurriness,
295
- backgroundIntensity,
296
- backgroundRotation,
297
- environmentIntensity,
298
- environmentRotation
234
+ function getRootState(obj) {
235
+ let state = obj.__r3f?.root.getState();
236
+ if (!state) {
237
+ obj.traverseAncestors((ancestor) => {
238
+ const parentState = ancestor.__r3f?.root.getState();
239
+ if (parentState) {
240
+ state = parentState;
241
+ return false;
242
+ }
299
243
  });
300
- });
301
- React.useEffect(() => {
302
- return () => {
303
- texture.dispose();
304
- };
305
- }, [texture]);
306
- return null;
244
+ }
245
+ return state;
307
246
  }
308
- function EnvironmentPortal({
309
- children,
310
- near = 0.1,
311
- far = 1e3,
312
- resolution = 256,
313
- frames = 1,
314
- map,
315
- background = false,
316
- blur,
317
- backgroundBlurriness,
318
- backgroundIntensity,
319
- backgroundRotation,
320
- environmentIntensity,
321
- environmentRotation,
322
- scene,
323
- files,
324
- path,
325
- preset = void 0,
326
- extensions
327
- }) {
328
- const renderer = useThree$1((state) => state.renderer);
329
- const isLegacy = useThree$1((state) => state.isLegacy);
330
- const defaultScene = useThree$1((state) => state.scene);
331
- const camera = React.useRef(null);
332
- const [virtualScene] = React.useState(() => new Scene());
333
- const fbo = React.useMemo(() => {
334
- const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
335
- fbo2.texture.type = HalfFloatType;
336
- return fbo2;
337
- }, [resolution, isLegacy]);
338
- React.useEffect(() => {
339
- return () => {
340
- fbo.dispose();
341
- };
342
- }, [fbo]);
343
- React.useLayoutEffect(() => {
344
- if (frames === 1) {
345
- const autoClear = renderer.autoClear;
346
- renderer.autoClear = true;
347
- camera.current.update(renderer, virtualScene);
348
- renderer.autoClear = autoClear;
349
- }
350
- return setEnvProps(background, scene, defaultScene, fbo.texture, {
351
- backgroundBlurriness: blur ?? backgroundBlurriness,
352
- backgroundIntensity,
353
- backgroundRotation,
354
- environmentIntensity,
355
- environmentRotation
247
+ function buildGraph(object) {
248
+ const data = { nodes: {}, materials: {}, meshes: {} };
249
+ if (object) {
250
+ object.traverse((obj) => {
251
+ if (obj.name) data.nodes[obj.name] = obj;
252
+ if (obj.material) {
253
+ const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
254
+ const nameAlreadyUsed = data.materials[material.name];
255
+ let materialName = material.name;
256
+ if (nameAlreadyUsed) {
257
+ materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
258
+ material.userData.materialCacheName = materialName;
259
+ }
260
+ data.materials[materialName] = material;
261
+ }
262
+ if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
356
263
  });
357
- }, [
358
- children,
359
- virtualScene,
360
- fbo.texture,
361
- scene,
362
- defaultScene,
363
- background,
364
- frames,
365
- renderer,
366
- blur,
367
- backgroundBlurriness,
368
- backgroundIntensity,
369
- backgroundRotation,
370
- environmentIntensity,
371
- environmentRotation
372
- ]);
373
- let count = 1;
374
- useFrame$1(() => {
375
- if (frames === Infinity || count < frames) {
376
- const autoClear = renderer.autoClear;
377
- renderer.autoClear = true;
378
- camera.current.update(renderer, virtualScene);
379
- renderer.autoClear = autoClear;
380
- count++;
381
- }
382
- });
383
- return /* @__PURE__ */ jsx(Fragment, { children: createPortal$1(
384
- /* @__PURE__ */ jsxs(Fragment, { children: [
385
- children,
386
- /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
387
- files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
388
- ] }),
389
- virtualScene
390
- ) });
264
+ }
265
+ return data;
391
266
  }
392
- function EnvironmentGround(props) {
393
- const textureDefault = useEnvironment(props);
394
- const texture = props.map || textureDefault;
395
- React.useMemo(() => extend$1({ GroundProjectedEnvImpl: GroundedSkybox }), []);
396
- React.useEffect(() => {
397
- return () => {
398
- textureDefault.dispose();
399
- };
400
- }, [textureDefault]);
401
- const height = props.ground?.height ?? 15;
402
- const radius = props.ground?.radius ?? 60;
403
- const scale = props.ground?.scale ?? 1e3;
404
- const args = React.useMemo(
405
- () => [texture, height, radius],
406
- [texture, height, radius]
407
- );
408
- return /* @__PURE__ */ jsxs(Fragment, { children: [
409
- /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
410
- /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
411
- ] });
267
+ function dispose(obj) {
268
+ if (obj.type !== "Scene") obj.dispose?.();
269
+ for (const p in obj) {
270
+ const prop = obj[p];
271
+ if (prop?.type !== "Scene") prop?.dispose?.();
272
+ }
412
273
  }
413
- function EnvironmentColor({ color, scene }) {
414
- const defaultScene = useThree$1((state) => state.scene);
415
- React.useLayoutEffect(() => {
416
- if (color === void 0) return;
417
- const target = resolveScene(scene || defaultScene);
418
- const oldBg = target.background;
419
- target.background = new Color(color);
420
- return () => {
421
- target.background = oldBg;
274
+ function getInstanceProps(pendingProps) {
275
+ const props = {};
276
+ for (const key in pendingProps) {
277
+ if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
278
+ }
279
+ return props;
280
+ }
281
+ function prepare(target, root, type, props) {
282
+ const object = target;
283
+ let instance = object?.__r3f;
284
+ if (!instance) {
285
+ instance = {
286
+ root,
287
+ type,
288
+ parent: null,
289
+ children: [],
290
+ props: getInstanceProps(props),
291
+ object,
292
+ eventCount: 0,
293
+ handlers: {},
294
+ isHidden: false
422
295
  };
423
- });
424
- return null;
296
+ if (object) object.__r3f = instance;
297
+ }
298
+ return instance;
425
299
  }
426
- function EnvironmentDualSource(props) {
427
- const { backgroundFiles, ...envProps } = props;
428
- return /* @__PURE__ */ jsxs(Fragment, { children: [
429
- /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
430
- /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
431
- ] });
300
+ function invalidateInstance(instance) {
301
+ if (!instance.parent) return;
302
+ instance.props.onUpdate?.(instance.object);
303
+ const state = instance.root?.getState?.();
304
+ if (state && state.internal.frames === 0) state.invalidate();
432
305
  }
433
- function Environment(props) {
434
- if (props.color && !props.files && !props.preset && !props.map) {
435
- return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
436
- }
437
- if (props.backgroundFiles && props.backgroundFiles !== props.files) {
438
- return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
306
+
307
+ const tempFrustum = new Frustum();
308
+ let hasWarnedWebGL = false;
309
+ let tslModule = null;
310
+ async function loadTSL() {
311
+ if (tslModule) return tslModule;
312
+ try {
313
+ const tsl = await import('three/tsl');
314
+ tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
315
+ return tslModule;
316
+ } catch {
317
+ return null;
439
318
  }
440
- return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
441
319
  }
442
-
443
- var __defProp = Object.defineProperty;
444
- var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
445
- var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
446
- const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
447
- function useMutableCallback(fn) {
448
- const ref = React.useRef(fn);
449
- useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
450
- return ref;
451
- }
452
- function useBridge() {
453
- const fiber = useFiber();
454
- const ContextBridge = useContextBridge();
455
- return React.useMemo(
456
- () => ({ children }) => {
457
- const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
458
- const Root = strict ? React.StrictMode : React.Fragment;
459
- return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
460
- },
461
- [fiber, ContextBridge]
462
- );
463
- }
464
- function Block({ set }) {
465
- useIsomorphicLayoutEffect(() => {
466
- set(new Promise(() => null));
467
- return () => set(false);
468
- }, [set]);
469
- return null;
470
- }
471
- const ErrorBoundary = /* @__PURE__ */ (() => {
472
- var _a;
473
- return _a = class extends React.Component {
474
- constructor() {
475
- super(...arguments);
476
- __publicField(this, "state", { error: false });
477
- }
478
- componentDidCatch(err) {
479
- this.props.set(err);
480
- }
481
- render() {
482
- return this.state.error ? null : this.props.children;
483
- }
484
- }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
485
- })();
486
-
487
- const is = {
488
- obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
489
- fun: (a) => typeof a === "function",
490
- str: (a) => typeof a === "string",
491
- num: (a) => typeof a === "number",
492
- boo: (a) => typeof a === "boolean",
493
- und: (a) => a === void 0,
494
- nul: (a) => a === null,
495
- arr: (a) => Array.isArray(a),
496
- equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
497
- if (typeof a !== typeof b || !!a !== !!b) return false;
498
- if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
499
- const isObj = is.obj(a);
500
- if (isObj && objects === "reference") return a === b;
501
- const isArr = is.arr(a);
502
- if (isArr && arrays === "reference") return a === b;
503
- if ((isArr || isObj) && a === b) return true;
504
- let i;
505
- for (i in a) if (!(i in b)) return false;
506
- if (isObj && arrays === "shallow" && objects === "shallow") {
507
- for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
508
- } else {
509
- for (i in strict ? b : a) if (a[i] !== b[i]) return false;
510
- }
511
- if (is.und(i)) {
512
- if (isArr && a.length === 0 && b.length === 0) return true;
513
- if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
514
- if (a !== b) return false;
515
- }
516
- return true;
517
- }
518
- };
519
- const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
520
- const isRef = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
521
- const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
522
- const isObject3D = (object) => object?.isObject3D;
523
- const isTexture = (value) => !!value?.isTexture;
524
- const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
525
- const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
526
- const hasConstructor = (object) => !!object?.constructor;
527
-
528
- function calculateDpr(dpr) {
529
- const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
530
- return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
531
- }
532
- function getUuidPrefix(uuid) {
533
- return uuid.split("-")[0];
534
- }
535
- function updateCamera(camera, size) {
536
- if (camera.manual) return;
537
- if (isOrthographicCamera(camera)) {
538
- camera.left = size.width / -2;
539
- camera.right = size.width / 2;
540
- camera.top = size.height / 2;
541
- camera.bottom = size.height / -2;
542
- } else {
543
- camera.aspect = size.width / size.height;
544
- }
545
- camera.updateProjectionMatrix();
546
- }
547
- const frustumMatrix = new Matrix4();
548
- function updateFrustum(camera, frustum) {
549
- const target = frustum ?? new Frustum();
550
- frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
551
- target.setFromProjectionMatrix(frustumMatrix);
552
- return target;
553
- }
554
-
555
- const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
556
- function findInitialRoot(instance) {
557
- let root = instance.root;
558
- while (root.getState().previousRoot) root = root.getState().previousRoot;
559
- return root;
560
- }
561
- function getRootState(obj) {
562
- let state = obj.__r3f?.root.getState();
563
- if (!state) {
564
- obj.traverseAncestors((ancestor) => {
565
- const parentState = ancestor.__r3f?.root.getState();
566
- if (parentState) {
567
- state = parentState;
568
- return false;
569
- }
570
- });
571
- }
572
- return state;
573
- }
574
- function buildGraph(object) {
575
- const data = { nodes: {}, materials: {}, meshes: {} };
576
- if (object) {
577
- object.traverse((obj) => {
578
- if (obj.name) data.nodes[obj.name] = obj;
579
- if (obj.material) {
580
- const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
581
- const nameAlreadyUsed = data.materials[material.name];
582
- let materialName = material.name;
583
- if (nameAlreadyUsed) {
584
- materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
585
- material.userData.materialCacheName = materialName;
586
- }
587
- data.materials[materialName] = material;
588
- }
589
- if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
590
- });
591
- }
592
- return data;
593
- }
594
- function dispose(obj) {
595
- if (obj.type !== "Scene") obj.dispose?.();
596
- for (const p in obj) {
597
- const prop = obj[p];
598
- if (prop?.type !== "Scene") prop?.dispose?.();
599
- }
600
- }
601
- function getInstanceProps(pendingProps) {
602
- const props = {};
603
- for (const key in pendingProps) {
604
- if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
605
- }
606
- return props;
607
- }
608
- function prepare(target, root, type, props) {
609
- const object = target;
610
- let instance = object?.__r3f;
611
- if (!instance) {
612
- instance = {
613
- root,
614
- type,
615
- parent: null,
616
- children: [],
617
- props: getInstanceProps(props),
618
- object,
619
- eventCount: 0,
620
- handlers: {},
621
- isHidden: false
622
- };
623
- if (object) object.__r3f = instance;
624
- }
625
- return instance;
626
- }
627
- function invalidateInstance(instance) {
628
- if (!instance.parent) return;
629
- instance.props.onUpdate?.(instance.object);
630
- const state = instance.root?.getState?.();
631
- if (state && state.internal.frames === 0) state.invalidate();
632
- }
633
-
634
- const tempFrustum = new Frustum();
635
- let hasWarnedWebGL = false;
636
- let tslModule = null;
637
- async function loadTSL() {
638
- if (tslModule) return tslModule;
639
- try {
640
- const tsl = await import('three/tsl');
641
- tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
642
- return tslModule;
643
- } catch {
644
- return null;
645
- }
646
- }
647
- function createOcclusionObserverNode(store, uniform) {
648
- const node = new Node("float");
649
- node.updateType = NodeUpdateType.OBJECT;
650
- node.update = function(frame) {
651
- const { internal } = store.getState();
652
- const registry = internal.visibilityRegistry;
653
- const cache = internal.occlusionCache;
654
- for (const entry of registry.values()) {
655
- const { object, handlers } = entry;
656
- if (handlers.onOccluded || handlers.onVisible) {
657
- const isOccluded = frame.renderer.isOccluded(object);
658
- cache.set(object, isOccluded);
659
- }
660
- }
661
- };
662
- node.setup = function() {
663
- return uniform(0);
664
- };
665
- return node;
320
+ function createOcclusionObserverNode(store, uniform) {
321
+ const node = new Node("float");
322
+ node.updateType = NodeUpdateType.OBJECT;
323
+ node.update = function(frame) {
324
+ const { internal } = store.getState();
325
+ const registry = internal.visibilityRegistry;
326
+ const cache = internal.occlusionCache;
327
+ for (const entry of registry.values()) {
328
+ const { object, handlers } = entry;
329
+ if (handlers.onOccluded || handlers.onVisible) {
330
+ const isOccluded = frame.renderer.isOccluded(object);
331
+ cache.set(object, isOccluded);
332
+ }
333
+ }
334
+ };
335
+ node.setup = function() {
336
+ return uniform(0);
337
+ };
338
+ return node;
666
339
  }
667
340
  let occlusionSetupPromise = null;
668
341
  function enableOcclusion(store) {
@@ -1065,914 +738,369 @@ function applyProps(object, props) {
1065
738
  return object;
1066
739
  }
1067
740
 
1068
- const DEFAULT_POINTER_ID = 0;
1069
- const XR_POINTER_ID_START = 1e3;
1070
- function getPointerState(internal, pointerId) {
1071
- let state = internal.pointerMap.get(pointerId);
1072
- if (!state) {
1073
- state = {
1074
- hovered: /* @__PURE__ */ new Map(),
1075
- captured: /* @__PURE__ */ new Map(),
1076
- initialClick: [0, 0],
1077
- initialHits: []
1078
- };
1079
- internal.pointerMap.set(pointerId, state);
741
+ const shownNotices = /* @__PURE__ */ new Set();
742
+ function notifyDepreciated({ heading, body, link }) {
743
+ if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
744
+ return;
1080
745
  }
1081
- return state;
1082
- }
1083
- function getPointerId(event) {
1084
- return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
1085
- }
1086
- function makeId(event) {
1087
- return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
1088
- }
1089
- function releaseInternalPointerCapture(internal, obj, pointerId) {
1090
- const pointerState = internal.pointerMap.get(pointerId);
1091
- if (!pointerState) return;
1092
- const captureData = pointerState.captured.get(obj);
1093
- if (captureData) {
1094
- pointerState.captured.delete(obj);
1095
- captureData.target.releasePointerCapture(pointerId);
746
+ if (shownNotices.has(heading)) return;
747
+ shownNotices.add(heading);
748
+ const caller = getCallerFrame();
749
+ if (caller) {
750
+ console.log();
1096
751
  }
1097
- }
1098
- function removeInteractivity(store, object) {
1099
- const { internal } = store.getState();
1100
- internal.interaction = internal.interaction.filter((o) => o !== object);
1101
- for (const [pointerId, pointerState] of internal.pointerMap) {
1102
- pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
1103
- pointerState.hovered.forEach((value, key) => {
1104
- if (value.eventObject === object || value.object === object) {
1105
- pointerState.hovered.delete(key);
1106
- }
1107
- });
1108
- if (pointerState.captured.has(object)) {
1109
- releaseInternalPointerCapture(internal, object, pointerId);
1110
- }
752
+ const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
753
+ if (caller) {
754
+ console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
755
+ }
756
+ if (body || link) {
757
+ let message = "";
758
+ if (body) message += body;
759
+ if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
760
+ console.warn(`%c${message}`, "font-weight: bold;");
1111
761
  }
1112
- unregisterVisibility(store, object);
1113
762
  }
1114
- function createEvents(store) {
1115
- function calculateDistance(event, pointerId) {
1116
- const { internal } = store.getState();
1117
- const pointerState = internal.pointerMap.get(pointerId);
1118
- if (!pointerState) return 0;
1119
- const [initialX, initialY] = pointerState.initialClick;
1120
- const dx = event.offsetX - initialX;
1121
- const dy = event.offsetY - initialY;
1122
- return Math.round(Math.sqrt(dx * dx + dy * dy));
763
+ function getCallerFrame(depth = 3) {
764
+ const stack = new Error().stack;
765
+ if (!stack) return null;
766
+ const lines = stack.split("\n");
767
+ const frame = lines[depth];
768
+ if (!frame) return null;
769
+ let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
770
+ if (!match) {
771
+ match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
1123
772
  }
1124
- function filterPointerEvents(objects) {
1125
- return objects.filter(
1126
- (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
1127
- (name) => obj.__r3f?.handlers["onPointer" + name]
1128
- ) || ["OverEnter", "OverLeave", "Over"].some(
1129
- (name) => obj.__r3f?.handlers["onDrag" + name]
1130
- ) || obj.__r3f?.handlers.onDrop
1131
- );
773
+ if (!match) return null;
774
+ const [, fn, url, line] = match;
775
+ return {
776
+ functionName: fn ?? "<anonymous>",
777
+ location: formatLocation(url, Number(line))
778
+ };
779
+ }
780
+ function formatLocation(url, line) {
781
+ const clean = url.split("?")[0];
782
+ const file = clean.split("/").pop() ?? clean;
783
+ return `${file}:${line}`;
784
+ }
785
+ function notifyAlpha({ message, link }) {
786
+ if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
787
+ return;
1132
788
  }
1133
- function intersect(event, filter) {
1134
- const state = store.getState();
1135
- const duplicates = /* @__PURE__ */ new Set();
1136
- const intersections = [];
1137
- const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
1138
- for (let i = 0; i < eventsObjects.length; i++) {
1139
- const state2 = getRootState(eventsObjects[i]);
1140
- if (state2) {
1141
- state2.raycaster.camera = void 0;
1142
- }
1143
- }
1144
- if (!state.previousRoot) {
1145
- state.events.compute?.(event, state);
1146
- }
1147
- function handleRaycast(obj) {
1148
- const state2 = getRootState(obj);
1149
- if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
1150
- if (state2.raycaster.camera === void 0) {
1151
- state2.events.compute?.(event, state2, state2.previousRoot?.getState());
1152
- if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
789
+ if (shownNotices.has(message)) return;
790
+ shownNotices.add(message);
791
+ const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
792
+ console.log(`%c\u{1F52C} ${message}`, boxStyle);
793
+ {
794
+ console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
795
+ }
796
+ }
797
+
798
+ const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
799
+ function isInternalRendererAccess(stack, callerDepth = 2) {
800
+ if (!stack) return false;
801
+ const caller = stack.split("\n")[callerDepth] ?? "";
802
+ return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
803
+ }
804
+
805
+ const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
806
+ const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React.createContext(null));
807
+ const createStore = (invalidate, advance) => {
808
+ const rootStore = createWithEqualityFn((set, get) => {
809
+ const position = new Vector3();
810
+ const defaultTarget = new Vector3();
811
+ const tempTarget = new Vector3();
812
+ function getCurrentViewport(camera = get().camera, target = defaultTarget, size = get().size) {
813
+ const { width, height, top, left } = size;
814
+ const aspect = width / height;
815
+ if (target.isVector3) tempTarget.copy(target);
816
+ else tempTarget.set(...target);
817
+ const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
818
+ if (isOrthographicCamera(camera)) {
819
+ return { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };
820
+ } else {
821
+ const fov = camera.fov * Math.PI / 180;
822
+ const h = 2 * Math.tan(fov / 2) * distance;
823
+ const w = h * (width / height);
824
+ return { width: w, height: h, top, left, factor: width / w, distance, aspect };
1153
825
  }
1154
- return state2.raycaster.camera ? state2.raycaster.intersectObject(obj, true) : [];
1155
826
  }
1156
- let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
1157
- const aInteractivePriority = a.object.userData?.interactivePriority;
1158
- const bInteractivePriority = b.object.userData?.interactivePriority;
1159
- if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
1160
- if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
1161
- if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
1162
- if (aInteractivePriority !== bInteractivePriority) {
1163
- return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
1164
- }
1165
- }
1166
- const aState = getRootState(a.object);
1167
- const bState = getRootState(b.object);
1168
- const aPriority = aState?.events?.priority ?? 1;
1169
- const bPriority = bState?.events?.priority ?? 1;
1170
- return bPriority - aPriority || a.distance - b.distance;
1171
- }).filter((item) => {
1172
- const id = makeId(item);
1173
- if (duplicates.has(id)) return false;
1174
- duplicates.add(id);
1175
- return true;
1176
- });
1177
- if (state.events.filter) hits = state.events.filter(hits, state);
1178
- for (const hit of hits) {
1179
- let eventObject = hit.object;
1180
- while (eventObject) {
1181
- if (eventObject.__r3f?.eventCount) {
1182
- intersections.push({ ...hit, eventObject });
827
+ let performanceTimeout = void 0;
828
+ const setPerformanceCurrent = (current) => set((state2) => ({ performance: { ...state2.performance, current } }));
829
+ const pointer = new Vector2();
830
+ const rootState = {
831
+ set,
832
+ get,
833
+ // Mock objects that have to be configured
834
+ // primaryStore is set after store creation (self-reference for primary, primary's store for secondary)
835
+ primaryStore: null,
836
+ gl: null,
837
+ renderer: null,
838
+ camera: null,
839
+ frustum: new Frustum(),
840
+ autoUpdateFrustum: true,
841
+ raycaster: null,
842
+ events: {
843
+ priority: 1,
844
+ enabled: true,
845
+ connected: false,
846
+ frameTimedRaycasts: true,
847
+ alwaysFireOnScroll: true,
848
+ updateOnFrame: false
849
+ },
850
+ scene: null,
851
+ rootScene: null,
852
+ xr: null,
853
+ inspector: null,
854
+ invalidate: (frames = 1, stackFrames = false) => invalidate(get(), frames, stackFrames),
855
+ advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, get()),
856
+ textureColorSpace: SRGBColorSpace,
857
+ isLegacy: false,
858
+ webGPUSupported: false,
859
+ isNative: false,
860
+ controls: null,
861
+ pointer,
862
+ mouse: pointer,
863
+ frameloop: "always",
864
+ onPointerMissed: void 0,
865
+ onDragOverMissed: void 0,
866
+ onDropMissed: void 0,
867
+ performance: {
868
+ current: 1,
869
+ min: 0.5,
870
+ max: 1,
871
+ debounce: 200,
872
+ regress: () => {
873
+ const state2 = get();
874
+ if (performanceTimeout) clearTimeout(performanceTimeout);
875
+ if (state2.performance.current !== state2.performance.min) setPerformanceCurrent(state2.performance.min);
876
+ performanceTimeout = setTimeout(
877
+ () => setPerformanceCurrent(get().performance.max),
878
+ state2.performance.debounce
879
+ );
1183
880
  }
1184
- eventObject = eventObject.parent;
1185
- }
1186
- }
1187
- if ("pointerId" in event) {
1188
- const pointerId = event.pointerId;
1189
- const pointerState = state.internal.pointerMap.get(pointerId);
1190
- if (pointerState?.captured.size) {
1191
- for (const captureData of pointerState.captured.values()) {
1192
- if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
881
+ },
882
+ size: { width: 0, height: 0, top: 0, left: 0 },
883
+ viewport: {
884
+ initialDpr: 0,
885
+ dpr: 0,
886
+ width: 0,
887
+ height: 0,
888
+ top: 0,
889
+ left: 0,
890
+ aspect: 0,
891
+ distance: 0,
892
+ factor: 0,
893
+ getCurrentViewport
894
+ },
895
+ setEvents: (events) => set((state2) => ({ ...state2, events: { ...state2.events, ...events } })),
896
+ setSize: (width, height, top, left) => {
897
+ const state2 = get();
898
+ if (width === void 0) {
899
+ set({ _sizeImperative: false });
900
+ if (state2._sizeProps) {
901
+ const { width: propW, height: propH } = state2._sizeProps;
902
+ if (propW !== void 0 || propH !== void 0) {
903
+ const currentSize = state2.size;
904
+ const newSize = {
905
+ width: propW ?? currentSize.width,
906
+ height: propH ?? currentSize.height,
907
+ top: currentSize.top,
908
+ left: currentSize.left
909
+ };
910
+ set((s) => ({
911
+ size: newSize,
912
+ viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, newSize) }
913
+ }));
914
+ getScheduler().invalidate();
915
+ }
916
+ }
917
+ return;
1193
918
  }
1194
- }
1195
- }
1196
- return intersections;
1197
- }
1198
- function handleIntersects(intersections, event, delta, callback) {
1199
- if (intersections.length) {
1200
- const localState = { stopped: false };
1201
- for (const hit of intersections) {
1202
- const state = getRootState(hit.object);
1203
- if (state) {
1204
- const { raycaster, pointer, camera, internal } = state;
1205
- const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
1206
- const hasPointerCapture = (id) => {
1207
- const pointerState = internal.pointerMap.get(id);
1208
- return pointerState?.captured.has(hit.eventObject) ?? false;
1209
- };
1210
- const setPointerCapture = (id) => {
1211
- const captureData = { intersection: hit, target: event.target };
1212
- const pointerState = getPointerState(internal, id);
1213
- pointerState.captured.set(hit.eventObject, captureData);
1214
- event.target.setPointerCapture(id);
1215
- };
1216
- const releasePointerCapture = (id) => {
1217
- releaseInternalPointerCapture(internal, hit.eventObject, id);
1218
- };
1219
- const extractEventProps = {};
1220
- for (const prop in event) {
1221
- const property = event[prop];
1222
- if (typeof property !== "function") extractEventProps[prop] = property;
1223
- }
1224
- const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
1225
- const raycastEvent = {
1226
- ...hit,
1227
- ...extractEventProps,
1228
- pointer,
1229
- intersections,
1230
- stopped: localState.stopped,
1231
- delta,
1232
- unprojectedPoint,
1233
- ray: raycaster.ray,
1234
- camera,
1235
- pointerId: eventPointerId,
1236
- // Hijack stopPropagation, which just sets a flag
1237
- stopPropagation() {
1238
- const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
1239
- if (
1240
- // ...if this pointer hasn't been captured
1241
- !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
1242
- pointerState.captured.has(hit.eventObject)
1243
- ) {
1244
- raycastEvent.stopped = localState.stopped = true;
1245
- if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
1246
- const higher = intersections.slice(0, intersections.indexOf(hit));
1247
- cancelPointer([...higher, hit], eventPointerId);
1248
- }
1249
- }
1250
- },
1251
- // there should be a distinction between target and currentTarget
1252
- target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
1253
- currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
1254
- nativeEvent: event
919
+ const w = width;
920
+ const h = height ?? width;
921
+ const t = top ?? state2.size.top;
922
+ const l = left ?? state2.size.left;
923
+ const size = { width: w, height: h, top: t, left: l };
924
+ set((s) => ({
925
+ size,
926
+ viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, size) },
927
+ _sizeImperative: true
928
+ }));
929
+ getScheduler().invalidate();
930
+ },
931
+ setDpr: (dpr) => set((state2) => {
932
+ const resolved = calculateDpr(dpr);
933
+ return { viewport: { ...state2.viewport, dpr: resolved, initialDpr: state2.viewport.initialDpr || resolved } };
934
+ }),
935
+ setFrameloop: (frameloop = "always") => {
936
+ set(() => ({ frameloop }));
937
+ getScheduler().frameloop = frameloop;
938
+ },
939
+ setError: (error) => set(() => ({ error })),
940
+ error: null,
941
+ //* TSL State (managed via hooks: useUniforms, useNodes, useBuffers, useGPUStorage, useTextures, useRenderPipeline) ==============================
942
+ uniforms: {},
943
+ nodes: {},
944
+ buffers: {},
945
+ gpuStorage: {},
946
+ textures: /* @__PURE__ */ new Map(),
947
+ _textureRefs: /* @__PURE__ */ new Map(),
948
+ renderPipeline: null,
949
+ passes: {},
950
+ _hmrVersion: 0,
951
+ _sizeImperative: false,
952
+ _sizeProps: null,
953
+ previousRoot: void 0,
954
+ internal: {
955
+ // Events
956
+ interaction: [],
957
+ subscribers: [],
958
+ // Per-pointer state (new unified structure)
959
+ pointerMap: /* @__PURE__ */ new Map(),
960
+ pointerDirty: /* @__PURE__ */ new Map(),
961
+ lastEvent: React.createRef(),
962
+ // Deprecated but kept for backwards compatibility
963
+ hovered: /* @__PURE__ */ new Map(),
964
+ initialClick: [0, 0],
965
+ initialHits: [],
966
+ capturedMap: /* @__PURE__ */ new Map(),
967
+ // Visibility tracking (onFramed, onOccluded, onVisible)
968
+ visibilityRegistry: /* @__PURE__ */ new Map(),
969
+ // Occlusion system (WebGPU only)
970
+ occlusionEnabled: false,
971
+ occlusionObserver: null,
972
+ occlusionCache: /* @__PURE__ */ new Map(),
973
+ helperGroup: null,
974
+ // Updates
975
+ active: false,
976
+ frames: 0,
977
+ priority: 0,
978
+ subscribe: (ref, priority, store) => {
979
+ const internal = get().internal;
980
+ internal.priority = internal.priority + (priority > 0 ? 1 : 0);
981
+ internal.subscribers.push({ ref, priority, store });
982
+ internal.subscribers = internal.subscribers.sort((a, b) => a.priority - b.priority);
983
+ return () => {
984
+ const internal2 = get().internal;
985
+ if (internal2?.subscribers) {
986
+ internal2.priority = internal2.priority - (priority > 0 ? 1 : 0);
987
+ internal2.subscribers = internal2.subscribers.filter((s) => s.ref !== ref);
988
+ }
1255
989
  };
1256
- callback(raycastEvent);
1257
- if (localState.stopped === true) break;
990
+ },
991
+ // Renderer Storage (single source of truth)
992
+ actualRenderer: null,
993
+ // Scheduler for useFrameNext (initialized in renderer.tsx)
994
+ scheduler: null
995
+ }
996
+ };
997
+ return rootState;
998
+ });
999
+ const state = rootStore.getState();
1000
+ Object.defineProperty(state, "gl", {
1001
+ get() {
1002
+ const currentState = rootStore.getState();
1003
+ if (!currentState.isLegacy && currentState.internal.actualRenderer) {
1004
+ const stack = new Error().stack || "";
1005
+ if (!isInternalRendererAccess(stack)) {
1006
+ const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
1007
+ notifyDepreciated({
1008
+ heading: "Accessing state.gl in WebGPU mode",
1009
+ body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
1010
+ });
1258
1011
  }
1259
1012
  }
1013
+ return currentState.internal.actualRenderer;
1014
+ },
1015
+ set(value) {
1016
+ rootStore.getState().internal.actualRenderer = value;
1017
+ },
1018
+ enumerable: true,
1019
+ configurable: true
1020
+ });
1021
+ Object.defineProperty(state, "renderer", {
1022
+ get() {
1023
+ return rootStore.getState().internal.actualRenderer;
1024
+ },
1025
+ set(value) {
1026
+ rootStore.getState().internal.actualRenderer = value;
1027
+ },
1028
+ enumerable: true,
1029
+ configurable: true
1030
+ });
1031
+ let oldScene = state.scene;
1032
+ rootStore.subscribe(() => {
1033
+ const currentState = rootStore.getState();
1034
+ const { scene, rootScene, set } = currentState;
1035
+ if (scene !== oldScene) {
1036
+ oldScene = scene;
1037
+ if (scene?.isScene && scene !== rootScene) {
1038
+ set({ rootScene: scene });
1039
+ }
1260
1040
  }
1261
- return intersections;
1262
- }
1263
- function cancelPointer(intersections, pointerId) {
1264
- const { internal } = store.getState();
1265
- const pid = pointerId ?? DEFAULT_POINTER_ID;
1266
- const pointerState = internal.pointerMap.get(pid);
1267
- if (!pointerState) return;
1268
- for (const [hoveredId, hoveredObj] of pointerState.hovered) {
1269
- if (!intersections.length || !intersections.find(
1270
- (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
1271
- )) {
1272
- const eventObject = hoveredObj.eventObject;
1273
- const instance = eventObject.__r3f;
1274
- pointerState.hovered.delete(hoveredId);
1275
- if (instance?.eventCount) {
1276
- const handlers = instance.handlers;
1277
- const data = { ...hoveredObj, intersections };
1278
- handlers.onPointerOut?.(data);
1279
- handlers.onPointerLeave?.(data);
1280
- handlers.onDragOverLeave?.(data);
1041
+ });
1042
+ let oldSize = state.size;
1043
+ let oldDpr = state.viewport.dpr;
1044
+ let oldCamera = state.camera;
1045
+ rootStore.subscribe(() => {
1046
+ const { camera, size, viewport, set, internal } = rootStore.getState();
1047
+ const actualRenderer = internal.actualRenderer;
1048
+ const canvasTarget = internal.canvasTarget;
1049
+ if (size.width !== oldSize.width || size.height !== oldSize.height || viewport.dpr !== oldDpr) {
1050
+ oldSize = size;
1051
+ oldDpr = viewport.dpr;
1052
+ updateCamera(camera, size);
1053
+ if (internal.isSecondary && canvasTarget) {
1054
+ if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1055
+ canvasTarget.setSize(size.width, size.height, false);
1056
+ } else {
1057
+ if (viewport.dpr > 0) actualRenderer.setPixelRatio(viewport.dpr);
1058
+ actualRenderer.setSize(size.width, size.height, false);
1059
+ if (canvasTarget) {
1060
+ if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1061
+ canvasTarget.setSize(size.width, size.height, false);
1281
1062
  }
1282
1063
  }
1283
1064
  }
1284
- }
1285
- function pointerMissed(event, objects) {
1286
- for (let i = 0; i < objects.length; i++) {
1287
- const instance = objects[i].__r3f;
1288
- instance?.handlers.onPointerMissed?.(event);
1065
+ if (camera !== oldCamera) {
1066
+ oldCamera = camera;
1067
+ const { rootScene } = rootStore.getState();
1068
+ if (camera && rootScene && !camera.parent) {
1069
+ rootScene.add(camera);
1070
+ }
1071
+ set((state2) => ({ viewport: { ...state2.viewport, ...state2.viewport.getCurrentViewport(camera) } }));
1072
+ const currentState = rootStore.getState();
1073
+ if (currentState.autoUpdateFrustum && camera) {
1074
+ updateFrustum(camera, currentState.frustum);
1075
+ }
1289
1076
  }
1290
- }
1291
- function dragOverMissed(event, objects) {
1292
- for (let i = 0; i < objects.length; i++) {
1293
- const instance = objects[i].__r3f;
1294
- instance?.handlers.onDragOverMissed?.(event);
1077
+ });
1078
+ rootStore.subscribe((state2) => invalidate(state2));
1079
+ return rootStore;
1080
+ };
1081
+
1082
+ const memoizedLoaders = /* @__PURE__ */ new WeakMap();
1083
+ const isConstructor$1 = (value) => typeof value === "function" && value?.prototype?.constructor === value;
1084
+ function getLoader$1(Proto) {
1085
+ if (isConstructor$1(Proto)) {
1086
+ let loader = memoizedLoaders.get(Proto);
1087
+ if (!loader) {
1088
+ loader = new Proto();
1089
+ memoizedLoaders.set(Proto, loader);
1295
1090
  }
1091
+ return loader;
1296
1092
  }
1297
- function dropMissed(event, objects) {
1298
- for (let i = 0; i < objects.length; i++) {
1299
- const instance = objects[i].__r3f;
1300
- instance?.handlers.onDropMissed?.(event);
1301
- }
1302
- }
1303
- function cleanupPointer(pointerId) {
1304
- const { internal } = store.getState();
1305
- const pointerState = internal.pointerMap.get(pointerId);
1306
- if (pointerState) {
1307
- for (const [, hoveredObj] of pointerState.hovered) {
1308
- const eventObject = hoveredObj.eventObject;
1309
- const instance = eventObject.__r3f;
1310
- if (instance?.eventCount) {
1311
- const handlers = instance.handlers;
1312
- const data = { ...hoveredObj, intersections: [] };
1313
- handlers.onPointerOut?.(data);
1314
- handlers.onPointerLeave?.(data);
1315
- }
1316
- }
1317
- internal.pointerMap.delete(pointerId);
1318
- }
1319
- internal.pointerDirty.delete(pointerId);
1320
- }
1321
- function processDeferredPointer(event, pointerId) {
1322
- const state = store.getState();
1323
- const { internal } = state;
1324
- if (!state.events.enabled) return;
1325
- const filter = filterPointerEvents;
1326
- const hits = intersect(event, filter);
1327
- cancelPointer(hits, pointerId);
1328
- function onIntersect(data) {
1329
- const eventObject = data.eventObject;
1330
- const instance = eventObject.__r3f;
1331
- if (!instance?.eventCount) return;
1332
- const handlers = instance.handlers;
1333
- if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
1334
- const id = makeId(data);
1335
- const pointerState = getPointerState(internal, pointerId);
1336
- const hoveredItem = pointerState.hovered.get(id);
1337
- if (!hoveredItem) {
1338
- pointerState.hovered.set(id, data);
1339
- handlers.onPointerOver?.(data);
1340
- handlers.onPointerEnter?.(data);
1341
- } else if (hoveredItem.stopped) {
1342
- data.stopPropagation();
1343
- }
1344
- }
1345
- handlers.onPointerMove?.(data);
1346
- }
1347
- handleIntersects(hits, event, 0, onIntersect);
1348
- }
1349
- function handlePointer(name) {
1350
- switch (name) {
1351
- case "onPointerLeave":
1352
- case "onDragLeave":
1353
- return () => cancelPointer([]);
1354
- // Global cancel of these events
1355
- case "onPointerCancel":
1356
- return (event) => {
1357
- const pointerId = getPointerId(event);
1358
- cleanupPointer(pointerId);
1359
- };
1360
- case "onLostPointerCapture":
1361
- return (event) => {
1362
- const { internal } = store.getState();
1363
- const pointerId = getPointerId(event);
1364
- const pointerState = internal.pointerMap.get(pointerId);
1365
- if (pointerState?.captured.size) {
1366
- requestAnimationFrame(() => {
1367
- const pointerState2 = internal.pointerMap.get(pointerId);
1368
- if (pointerState2?.captured.size) {
1369
- pointerState2.captured.clear();
1370
- }
1371
- cancelPointer([], pointerId);
1372
- });
1373
- }
1374
- };
1375
- }
1376
- return function handleEvent(event) {
1377
- const state = store.getState();
1378
- const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
1379
- const pointerId = getPointerId(event);
1380
- internal.lastEvent.current = event;
1381
- if (!events.enabled) return;
1382
- const isPointerMove = name === "onPointerMove";
1383
- const isDragOver = name === "onDragOver";
1384
- const isDrop = name === "onDrop";
1385
- const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
1386
- const isPointerDown = name === "onPointerDown";
1387
- const isPointerUp = name === "onPointerUp";
1388
- const isWheel = name === "onWheel";
1389
- const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
1390
- if (isPointerMove && canDeferRaycasts) {
1391
- events.compute?.(event, state);
1392
- internal.pointerDirty.set(pointerId, event);
1393
- return;
1394
- }
1395
- if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
1396
- events.compute?.(event, state);
1397
- internal.pointerDirty.set(pointerId, event);
1398
- return;
1399
- }
1400
- if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
1401
- const deferredEvent = internal.pointerDirty.get(pointerId);
1402
- internal.pointerDirty.delete(pointerId);
1403
- processDeferredPointer(deferredEvent, pointerId);
1404
- }
1405
- const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
1406
- const hits = intersect(event, filter);
1407
- const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
1408
- if (isPointerDown) {
1409
- const pointerState2 = getPointerState(internal, pointerId);
1410
- pointerState2.initialClick = [event.offsetX, event.offsetY];
1411
- pointerState2.initialHits = hits.map((hit) => hit.eventObject);
1412
- }
1413
- const pointerState = internal.pointerMap.get(pointerId);
1414
- const initialHits = pointerState?.initialHits ?? [];
1415
- if (isClickEvent && !hits.length) {
1416
- if (delta <= 2) {
1417
- pointerMissed(event, internal.interaction);
1418
- if (onPointerMissed) onPointerMissed(event);
1419
- }
1420
- }
1421
- if (isDragOver && !hits.length) {
1422
- dragOverMissed(event, internal.interaction);
1423
- if (onDragOverMissed) onDragOverMissed(event);
1424
- }
1425
- if (isDrop && !hits.length) {
1426
- dropMissed(event, internal.interaction);
1427
- if (onDropMissed) onDropMissed(event);
1428
- }
1429
- if (isPointerMove || isDragOver) {
1430
- cancelPointer(hits, pointerId);
1431
- }
1432
- function onIntersect(data) {
1433
- const eventObject = data.eventObject;
1434
- const instance = eventObject.__r3f;
1435
- if (!instance?.eventCount) return;
1436
- const handlers = instance.handlers;
1437
- if (isPointerMove) {
1438
- if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
1439
- const id = makeId(data);
1440
- const pointerState2 = getPointerState(internal, pointerId);
1441
- const hoveredItem = pointerState2.hovered.get(id);
1442
- if (!hoveredItem) {
1443
- pointerState2.hovered.set(id, data);
1444
- handlers.onPointerOver?.(data);
1445
- handlers.onPointerEnter?.(data);
1446
- } else if (hoveredItem.stopped) {
1447
- data.stopPropagation();
1448
- }
1449
- }
1450
- handlers.onPointerMove?.(data);
1451
- } else if (isDragOver) {
1452
- const id = makeId(data);
1453
- const pointerState2 = getPointerState(internal, pointerId);
1454
- const hoveredItem = pointerState2.hovered.get(id);
1455
- if (!hoveredItem) {
1456
- pointerState2.hovered.set(id, data);
1457
- handlers.onDragOverEnter?.(data);
1458
- } else if (hoveredItem.stopped) {
1459
- data.stopPropagation();
1460
- }
1461
- handlers.onDragOver?.(data);
1462
- } else if (isDrop) {
1463
- handlers.onDrop?.(data);
1464
- } else {
1465
- const handler = handlers[name];
1466
- if (handler) {
1467
- if (!isClickEvent || initialHits.includes(eventObject)) {
1468
- pointerMissed(
1469
- event,
1470
- internal.interaction.filter((object) => !initialHits.includes(object))
1471
- );
1472
- handler(data);
1473
- }
1474
- } else {
1475
- if (isClickEvent && initialHits.includes(eventObject)) {
1476
- pointerMissed(
1477
- event,
1478
- internal.interaction.filter((object) => !initialHits.includes(object))
1479
- );
1480
- }
1481
- }
1482
- }
1483
- }
1484
- handleIntersects(hits, event, delta, onIntersect);
1485
- };
1486
- }
1487
- function flushDeferredPointers() {
1488
- const { internal, events } = store.getState();
1489
- if (!events.frameTimedRaycasts) return;
1490
- for (const [pointerId, event] of internal.pointerDirty) {
1491
- processDeferredPointer(event, pointerId);
1492
- }
1493
- internal.pointerDirty.clear();
1494
- }
1495
- return { handlePointer, flushDeferredPointers, processDeferredPointer };
1496
- }
1497
- const DOM_EVENTS = {
1498
- onClick: ["click", false],
1499
- onContextMenu: ["contextmenu", false],
1500
- onDoubleClick: ["dblclick", false],
1501
- onDragEnter: ["dragenter", false],
1502
- onDragLeave: ["dragleave", false],
1503
- onDragOver: ["dragover", false],
1504
- onDrop: ["drop", false],
1505
- onWheel: ["wheel", true],
1506
- onPointerDown: ["pointerdown", true],
1507
- onPointerUp: ["pointerup", true],
1508
- onPointerLeave: ["pointerleave", true],
1509
- onPointerMove: ["pointermove", true],
1510
- onPointerCancel: ["pointercancel", true],
1511
- onLostPointerCapture: ["lostpointercapture", true]
1512
- };
1513
- function createPointerEvents(store) {
1514
- const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
1515
- let nextXRPointerId = XR_POINTER_ID_START;
1516
- const xrPointers = /* @__PURE__ */ new Map();
1517
- return {
1518
- priority: 1,
1519
- enabled: true,
1520
- frameTimedRaycasts: true,
1521
- alwaysFireOnScroll: true,
1522
- updateOnFrame: false,
1523
- compute(event, state) {
1524
- state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
1525
- state.raycaster.setFromCamera(state.pointer, state.camera);
1526
- },
1527
- connected: void 0,
1528
- handlers: Object.keys(DOM_EVENTS).reduce(
1529
- (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
1530
- {}
1531
- ),
1532
- update: (pointerId) => {
1533
- const { events, internal } = store.getState();
1534
- if (!events.handlers) return;
1535
- if (pointerId !== void 0) {
1536
- const event = internal.pointerDirty.get(pointerId);
1537
- if (event) {
1538
- internal.pointerDirty.delete(pointerId);
1539
- processDeferredPointer(event, pointerId);
1540
- } else if (internal.lastEvent?.current) {
1541
- processDeferredPointer(internal.lastEvent.current, pointerId);
1542
- }
1543
- } else {
1544
- flushDeferredPointers();
1545
- if (internal.lastEvent?.current) {
1546
- events.handlers.onPointerMove(internal.lastEvent.current);
1547
- }
1548
- }
1549
- },
1550
- flush: () => {
1551
- const { events, internal } = store.getState();
1552
- flushDeferredPointers();
1553
- if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
1554
- events.handlers.onPointerMove(internal.lastEvent.current);
1555
- }
1556
- },
1557
- connect: (target) => {
1558
- if (!target) return;
1559
- const { set, events } = store.getState();
1560
- events.disconnect?.();
1561
- set((state) => ({ events: { ...state.events, connected: target } }));
1562
- if (events.handlers) {
1563
- for (const name in events.handlers) {
1564
- const event = events.handlers[name];
1565
- const [eventName, passive] = DOM_EVENTS[name];
1566
- target.addEventListener(eventName, event, { passive });
1567
- }
1568
- }
1569
- },
1570
- disconnect: () => {
1571
- const { set, events } = store.getState();
1572
- if (events.connected) {
1573
- if (events.handlers) {
1574
- for (const name in events.handlers) {
1575
- const event = events.handlers[name];
1576
- const [eventName] = DOM_EVENTS[name];
1577
- events.connected.removeEventListener(eventName, event);
1578
- }
1579
- }
1580
- set((state) => ({ events: { ...state.events, connected: void 0 } }));
1581
- }
1582
- },
1583
- // PREVIEW (A8): the XR pointer registration API may change before stable.
1584
- registerPointer: (config) => {
1585
- const pointerId = nextXRPointerId++;
1586
- xrPointers.set(pointerId, config);
1587
- const { internal } = store.getState();
1588
- getPointerState(internal, pointerId);
1589
- return pointerId;
1590
- },
1591
- unregisterPointer: (pointerId) => {
1592
- xrPointers.delete(pointerId);
1593
- const { internal } = store.getState();
1594
- const pointerState = internal.pointerMap.get(pointerId);
1595
- if (pointerState) {
1596
- for (const [, hoveredObj] of pointerState.hovered) {
1597
- const eventObject = hoveredObj.eventObject;
1598
- const instance = eventObject.__r3f;
1599
- if (instance?.eventCount) {
1600
- const handlers = instance.handlers;
1601
- const data = { ...hoveredObj, intersections: [] };
1602
- handlers.onPointerOut?.(data);
1603
- handlers.onPointerLeave?.(data);
1604
- }
1605
- }
1606
- internal.pointerMap.delete(pointerId);
1607
- }
1608
- internal.pointerDirty.delete(pointerId);
1609
- }
1610
- };
1611
- }
1612
-
1613
- const shownNotices = /* @__PURE__ */ new Set();
1614
- function notifyDepreciated({ heading, body, link }) {
1615
- if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
1616
- return;
1617
- }
1618
- if (shownNotices.has(heading)) return;
1619
- shownNotices.add(heading);
1620
- const caller = getCallerFrame();
1621
- if (caller) {
1622
- console.log();
1623
- }
1624
- const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
1625
- if (caller) {
1626
- console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
1627
- }
1628
- if (body || link) {
1629
- let message = "";
1630
- if (body) message += body;
1631
- if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
1632
- console.warn(`%c${message}`, "font-weight: bold;");
1633
- }
1634
- }
1635
- function getCallerFrame(depth = 3) {
1636
- const stack = new Error().stack;
1637
- if (!stack) return null;
1638
- const lines = stack.split("\n");
1639
- const frame = lines[depth];
1640
- if (!frame) return null;
1641
- let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
1642
- if (!match) {
1643
- match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
1644
- }
1645
- if (!match) return null;
1646
- const [, fn, url, line] = match;
1647
- return {
1648
- functionName: fn ?? "<anonymous>",
1649
- location: formatLocation(url, Number(line))
1650
- };
1651
- }
1652
- function formatLocation(url, line) {
1653
- const clean = url.split("?")[0];
1654
- const file = clean.split("/").pop() ?? clean;
1655
- return `${file}:${line}`;
1656
- }
1657
- function notifyAlpha({ message, link }) {
1658
- if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
1659
- return;
1660
- }
1661
- if (shownNotices.has(message)) return;
1662
- shownNotices.add(message);
1663
- const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
1664
- console.log(`%c\u{1F52C} ${message}`, boxStyle);
1665
- {
1666
- console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
1667
- }
1668
- }
1669
-
1670
- const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
1671
- function isInternalRendererAccess(stack, callerDepth = 2) {
1672
- if (!stack) return false;
1673
- const caller = stack.split("\n")[callerDepth] ?? "";
1674
- return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
1675
- }
1676
-
1677
- const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
1678
- const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React.createContext(null));
1679
- const createStore = (invalidate, advance) => {
1680
- const rootStore = createWithEqualityFn((set, get) => {
1681
- const position = new Vector3();
1682
- const defaultTarget = new Vector3();
1683
- const tempTarget = new Vector3();
1684
- function getCurrentViewport(camera = get().camera, target = defaultTarget, size = get().size) {
1685
- const { width, height, top, left } = size;
1686
- const aspect = width / height;
1687
- if (target.isVector3) tempTarget.copy(target);
1688
- else tempTarget.set(...target);
1689
- const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
1690
- if (isOrthographicCamera(camera)) {
1691
- return { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };
1692
- } else {
1693
- const fov = camera.fov * Math.PI / 180;
1694
- const h = 2 * Math.tan(fov / 2) * distance;
1695
- const w = h * (width / height);
1696
- return { width: w, height: h, top, left, factor: width / w, distance, aspect };
1697
- }
1698
- }
1699
- let performanceTimeout = void 0;
1700
- const setPerformanceCurrent = (current) => set((state2) => ({ performance: { ...state2.performance, current } }));
1701
- const pointer = new Vector2();
1702
- const rootState = {
1703
- set,
1704
- get,
1705
- // Mock objects that have to be configured
1706
- // primaryStore is set after store creation (self-reference for primary, primary's store for secondary)
1707
- primaryStore: null,
1708
- gl: null,
1709
- renderer: null,
1710
- camera: null,
1711
- frustum: new Frustum(),
1712
- autoUpdateFrustum: true,
1713
- raycaster: null,
1714
- events: {
1715
- priority: 1,
1716
- enabled: true,
1717
- connected: false,
1718
- frameTimedRaycasts: true,
1719
- alwaysFireOnScroll: true,
1720
- updateOnFrame: false
1721
- },
1722
- scene: null,
1723
- rootScene: null,
1724
- xr: null,
1725
- inspector: null,
1726
- invalidate: (frames = 1, stackFrames = false) => invalidate(get(), frames, stackFrames),
1727
- advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, get()),
1728
- textureColorSpace: SRGBColorSpace,
1729
- isLegacy: false,
1730
- webGPUSupported: false,
1731
- isNative: false,
1732
- controls: null,
1733
- pointer,
1734
- mouse: pointer,
1735
- frameloop: "always",
1736
- onPointerMissed: void 0,
1737
- onDragOverMissed: void 0,
1738
- onDropMissed: void 0,
1739
- performance: {
1740
- current: 1,
1741
- min: 0.5,
1742
- max: 1,
1743
- debounce: 200,
1744
- regress: () => {
1745
- const state2 = get();
1746
- if (performanceTimeout) clearTimeout(performanceTimeout);
1747
- if (state2.performance.current !== state2.performance.min) setPerformanceCurrent(state2.performance.min);
1748
- performanceTimeout = setTimeout(
1749
- () => setPerformanceCurrent(get().performance.max),
1750
- state2.performance.debounce
1751
- );
1752
- }
1753
- },
1754
- size: { width: 0, height: 0, top: 0, left: 0 },
1755
- viewport: {
1756
- initialDpr: 0,
1757
- dpr: 0,
1758
- width: 0,
1759
- height: 0,
1760
- top: 0,
1761
- left: 0,
1762
- aspect: 0,
1763
- distance: 0,
1764
- factor: 0,
1765
- getCurrentViewport
1766
- },
1767
- setEvents: (events) => set((state2) => ({ ...state2, events: { ...state2.events, ...events } })),
1768
- setSize: (width, height, top, left) => {
1769
- const state2 = get();
1770
- if (width === void 0) {
1771
- set({ _sizeImperative: false });
1772
- if (state2._sizeProps) {
1773
- const { width: propW, height: propH } = state2._sizeProps;
1774
- if (propW !== void 0 || propH !== void 0) {
1775
- const currentSize = state2.size;
1776
- const newSize = {
1777
- width: propW ?? currentSize.width,
1778
- height: propH ?? currentSize.height,
1779
- top: currentSize.top,
1780
- left: currentSize.left
1781
- };
1782
- set((s) => ({
1783
- size: newSize,
1784
- viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, newSize) }
1785
- }));
1786
- getScheduler().invalidate();
1787
- }
1788
- }
1789
- return;
1790
- }
1791
- const w = width;
1792
- const h = height ?? width;
1793
- const t = top ?? state2.size.top;
1794
- const l = left ?? state2.size.left;
1795
- const size = { width: w, height: h, top: t, left: l };
1796
- set((s) => ({
1797
- size,
1798
- viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, size) },
1799
- _sizeImperative: true
1800
- }));
1801
- getScheduler().invalidate();
1802
- },
1803
- setDpr: (dpr) => set((state2) => {
1804
- const resolved = calculateDpr(dpr);
1805
- return { viewport: { ...state2.viewport, dpr: resolved, initialDpr: state2.viewport.initialDpr || resolved } };
1806
- }),
1807
- setFrameloop: (frameloop = "always") => {
1808
- set(() => ({ frameloop }));
1809
- getScheduler().frameloop = frameloop;
1810
- },
1811
- setError: (error) => set(() => ({ error })),
1812
- error: null,
1813
- //* TSL State (managed via hooks: useUniforms, useNodes, useBuffers, useGPUStorage, useTextures, useRenderPipeline) ==============================
1814
- uniforms: {},
1815
- nodes: {},
1816
- buffers: {},
1817
- gpuStorage: {},
1818
- textures: /* @__PURE__ */ new Map(),
1819
- _textureRefs: /* @__PURE__ */ new Map(),
1820
- renderPipeline: null,
1821
- passes: {},
1822
- _hmrVersion: 0,
1823
- _sizeImperative: false,
1824
- _sizeProps: null,
1825
- previousRoot: void 0,
1826
- internal: {
1827
- // Events
1828
- interaction: [],
1829
- subscribers: [],
1830
- // Per-pointer state (new unified structure)
1831
- pointerMap: /* @__PURE__ */ new Map(),
1832
- pointerDirty: /* @__PURE__ */ new Map(),
1833
- lastEvent: React.createRef(),
1834
- // Deprecated but kept for backwards compatibility
1835
- hovered: /* @__PURE__ */ new Map(),
1836
- initialClick: [0, 0],
1837
- initialHits: [],
1838
- capturedMap: /* @__PURE__ */ new Map(),
1839
- // Visibility tracking (onFramed, onOccluded, onVisible)
1840
- visibilityRegistry: /* @__PURE__ */ new Map(),
1841
- // Occlusion system (WebGPU only)
1842
- occlusionEnabled: false,
1843
- occlusionObserver: null,
1844
- occlusionCache: /* @__PURE__ */ new Map(),
1845
- helperGroup: null,
1846
- // Updates
1847
- active: false,
1848
- frames: 0,
1849
- priority: 0,
1850
- subscribe: (ref, priority, store) => {
1851
- const internal = get().internal;
1852
- internal.priority = internal.priority + (priority > 0 ? 1 : 0);
1853
- internal.subscribers.push({ ref, priority, store });
1854
- internal.subscribers = internal.subscribers.sort((a, b) => a.priority - b.priority);
1855
- return () => {
1856
- const internal2 = get().internal;
1857
- if (internal2?.subscribers) {
1858
- internal2.priority = internal2.priority - (priority > 0 ? 1 : 0);
1859
- internal2.subscribers = internal2.subscribers.filter((s) => s.ref !== ref);
1860
- }
1861
- };
1862
- },
1863
- // Renderer Storage (single source of truth)
1864
- actualRenderer: null,
1865
- // Scheduler for useFrameNext (initialized in renderer.tsx)
1866
- scheduler: null
1867
- }
1868
- };
1869
- return rootState;
1870
- });
1871
- const state = rootStore.getState();
1872
- Object.defineProperty(state, "gl", {
1873
- get() {
1874
- const currentState = rootStore.getState();
1875
- if (!currentState.isLegacy && currentState.internal.actualRenderer) {
1876
- const stack = new Error().stack || "";
1877
- if (!isInternalRendererAccess(stack)) {
1878
- const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
1879
- notifyDepreciated({
1880
- heading: "Accessing state.gl in WebGPU mode",
1881
- body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
1882
- });
1883
- }
1884
- }
1885
- return currentState.internal.actualRenderer;
1886
- },
1887
- set(value) {
1888
- rootStore.getState().internal.actualRenderer = value;
1889
- },
1890
- enumerable: true,
1891
- configurable: true
1892
- });
1893
- Object.defineProperty(state, "renderer", {
1894
- get() {
1895
- return rootStore.getState().internal.actualRenderer;
1896
- },
1897
- set(value) {
1898
- rootStore.getState().internal.actualRenderer = value;
1899
- },
1900
- enumerable: true,
1901
- configurable: true
1902
- });
1903
- let oldScene = state.scene;
1904
- rootStore.subscribe(() => {
1905
- const currentState = rootStore.getState();
1906
- const { scene, rootScene, set } = currentState;
1907
- if (scene !== oldScene) {
1908
- oldScene = scene;
1909
- if (scene?.isScene && scene !== rootScene) {
1910
- set({ rootScene: scene });
1911
- }
1912
- }
1913
- });
1914
- let oldSize = state.size;
1915
- let oldDpr = state.viewport.dpr;
1916
- let oldCamera = state.camera;
1917
- rootStore.subscribe(() => {
1918
- const { camera, size, viewport, set, internal } = rootStore.getState();
1919
- const actualRenderer = internal.actualRenderer;
1920
- const canvasTarget = internal.canvasTarget;
1921
- if (size.width !== oldSize.width || size.height !== oldSize.height || viewport.dpr !== oldDpr) {
1922
- oldSize = size;
1923
- oldDpr = viewport.dpr;
1924
- updateCamera(camera, size);
1925
- if (internal.isSecondary && canvasTarget) {
1926
- if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1927
- canvasTarget.setSize(size.width, size.height, false);
1928
- } else {
1929
- if (viewport.dpr > 0) actualRenderer.setPixelRatio(viewport.dpr);
1930
- actualRenderer.setSize(size.width, size.height, false);
1931
- if (canvasTarget) {
1932
- if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1933
- canvasTarget.setSize(size.width, size.height, false);
1934
- }
1935
- }
1936
- }
1937
- if (camera !== oldCamera) {
1938
- oldCamera = camera;
1939
- const { rootScene } = rootStore.getState();
1940
- if (camera && rootScene && !camera.parent) {
1941
- rootScene.add(camera);
1942
- }
1943
- set((state2) => ({ viewport: { ...state2.viewport, ...state2.viewport.getCurrentViewport(camera) } }));
1944
- const currentState = rootStore.getState();
1945
- if (currentState.autoUpdateFrustum && camera) {
1946
- updateFrustum(camera, currentState.frustum);
1947
- }
1948
- }
1949
- });
1950
- rootStore.subscribe((state2) => invalidate(state2));
1951
- return rootStore;
1952
- };
1953
-
1954
- const memoizedLoaders = /* @__PURE__ */ new WeakMap();
1955
- const isConstructor$1 = (value) => typeof value === "function" && value?.prototype?.constructor === value;
1956
- function getLoader(Proto) {
1957
- if (isConstructor$1(Proto)) {
1958
- let loader = memoizedLoaders.get(Proto);
1959
- if (!loader) {
1960
- loader = new Proto();
1961
- memoizedLoaders.set(Proto, loader);
1962
- }
1963
- return loader;
1964
- }
1965
- return Proto;
1966
- }
1967
- function loadingFn(extensions, onProgress) {
1968
- return function(Proto, input) {
1969
- const loader = getLoader(Proto);
1970
- if (extensions) extensions(loader);
1971
- if ("loadAsync" in loader && typeof loader.loadAsync === "function") {
1972
- return loader.loadAsync(input, onProgress).then((data) => {
1973
- if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
1974
- return data;
1975
- });
1093
+ return Proto;
1094
+ }
1095
+ function loadingFn(extensions, onProgress) {
1096
+ return function(Proto, input) {
1097
+ const loader = getLoader$1(Proto);
1098
+ if (extensions) extensions(loader);
1099
+ if ("loadAsync" in loader && typeof loader.loadAsync === "function") {
1100
+ return loader.loadAsync(input, onProgress).then((data) => {
1101
+ if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
1102
+ return data;
1103
+ });
1976
1104
  }
1977
1105
  return new Promise(
1978
1106
  (res, reject) => loader.load(
@@ -2007,7 +1135,7 @@ useLoader.clear = function(loader, input, cacheKey) {
2007
1135
  const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
2008
1136
  cacheKeys.forEach((key) => clear([loader, key]));
2009
1137
  };
2010
- useLoader.loader = getLoader;
1138
+ useLoader.loader = getLoader$1;
2011
1139
 
2012
1140
  function useFrame(callback, priorityOrOptions) {
2013
1141
  const store = React.useContext(context);
@@ -2367,11 +1495,131 @@ function useRenderTarget(widthOrOptions, heightOrOptions, options) {
2367
1495
  height = widthOrOptions;
2368
1496
  }
2369
1497
  }
2370
- return useMemo(() => {
2371
- const w = width ?? size.width;
2372
- const h = height ?? size.height;
2373
- return new WebGLRenderTarget(w, h, opts);
2374
- }, [width, height, size.width, size.height, opts, isLegacy]);
1498
+ return useMemo(() => {
1499
+ const w = width ?? size.width;
1500
+ const h = height ?? size.height;
1501
+ return new WebGLRenderTarget(w, h, opts);
1502
+ }, [width, height, size.width, size.height, opts, isLegacy]);
1503
+ }
1504
+
1505
+ const presetsObj = {
1506
+ apartment: "lebombo_1k.hdr",
1507
+ city: "potsdamer_platz_1k.hdr",
1508
+ dawn: "kiara_1_dawn_1k.hdr",
1509
+ forest: "forest_slope_1k.hdr",
1510
+ lobby: "st_fagans_interior_1k.hdr",
1511
+ night: "dikhololo_night_1k.hdr",
1512
+ park: "rooitou_park_1k.hdr",
1513
+ studio: "studio_small_03_1k.hdr",
1514
+ sunset: "venice_sunset_1k.hdr",
1515
+ warehouse: "empty_warehouse_01_1k.hdr"
1516
+ };
1517
+
1518
+ const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
1519
+ const isArray = (arr) => Array.isArray(arr);
1520
+ const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
1521
+ function useEnvironment({
1522
+ files = defaultFiles,
1523
+ path = "",
1524
+ preset = void 0,
1525
+ colorSpace = void 0,
1526
+ extensions
1527
+ } = {}) {
1528
+ if (preset) {
1529
+ validatePreset(preset);
1530
+ files = presetsObj[preset];
1531
+ path = CUBEMAP_ROOT;
1532
+ }
1533
+ const multiFile = isArray(files);
1534
+ const { extension, isCubemap } = getExtension(files);
1535
+ const loader = getLoader(extension);
1536
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1537
+ const renderer = useThree((state) => state.renderer);
1538
+ useLayoutEffect(() => {
1539
+ if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
1540
+ function clearGainmapTexture() {
1541
+ useLoader.clear(loader, multiFile ? [files] : files);
1542
+ }
1543
+ renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
1544
+ }, [extension, files, loader, multiFile, renderer.domElement]);
1545
+ const loaderResult = useLoader(
1546
+ loader,
1547
+ multiFile ? [files] : files,
1548
+ (loader2) => {
1549
+ if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
1550
+ loader2.setRenderer?.(renderer);
1551
+ }
1552
+ loader2.setPath?.(path);
1553
+ if (extensions) extensions(loader2);
1554
+ }
1555
+ );
1556
+ let texture = multiFile ? (
1557
+ // @ts-ignore
1558
+ loaderResult[0]
1559
+ ) : loaderResult;
1560
+ if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
1561
+ texture = texture.renderTarget?.texture;
1562
+ }
1563
+ texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
1564
+ texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
1565
+ return texture;
1566
+ }
1567
+ const preloadDefaultOptions = {
1568
+ files: defaultFiles,
1569
+ path: "",
1570
+ preset: void 0,
1571
+ extensions: void 0
1572
+ };
1573
+ useEnvironment.preload = (preloadOptions) => {
1574
+ const options = { ...preloadDefaultOptions, ...preloadOptions };
1575
+ let { files, path = "" } = options;
1576
+ const { preset, extensions } = options;
1577
+ if (preset) {
1578
+ validatePreset(preset);
1579
+ files = presetsObj[preset];
1580
+ path = CUBEMAP_ROOT;
1581
+ }
1582
+ const { extension } = getExtension(files);
1583
+ if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
1584
+ throw new Error("useEnvironment: Preloading gainmaps is not supported");
1585
+ }
1586
+ const loader = getLoader(extension);
1587
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1588
+ useLoader.preload(loader, isArray(files) ? [files] : files, (loader2) => {
1589
+ loader2.setPath?.(path);
1590
+ if (extensions) extensions(loader2);
1591
+ });
1592
+ };
1593
+ const clearDefaultOptins = {
1594
+ files: defaultFiles,
1595
+ preset: void 0
1596
+ };
1597
+ useEnvironment.clear = (clearOptions) => {
1598
+ const options = { ...clearDefaultOptins, ...clearOptions };
1599
+ let { files } = options;
1600
+ const { preset } = options;
1601
+ if (preset) {
1602
+ validatePreset(preset);
1603
+ files = presetsObj[preset];
1604
+ }
1605
+ const { extension } = getExtension(files);
1606
+ const loader = getLoader(extension);
1607
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1608
+ useLoader.clear(loader, isArray(files) ? [files] : files);
1609
+ };
1610
+ function validatePreset(preset) {
1611
+ if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
1612
+ }
1613
+ function getExtension(files) {
1614
+ const isCubemap = isArray(files) && files.length === 6;
1615
+ const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
1616
+ const firstEntry = isArray(files) ? files[0] : files;
1617
+ const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
1618
+ return { extension, isCubemap, isGainmap };
1619
+ }
1620
+ function getLoader(extension) {
1621
+ const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
1622
+ return loader;
2375
1623
  }
2376
1624
 
2377
1625
  function useStore() {
@@ -2391,6 +1639,8 @@ function useGraph(object) {
2391
1639
  return useMemo(() => buildGraph(object), [object]);
2392
1640
  }
2393
1641
 
1642
+ const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
1643
+
2394
1644
  let effectId = 0;
2395
1645
  function addEffect(callback) {
2396
1646
  notifyDepreciated({
@@ -13293,395 +12543,978 @@ Check the top-level render call using <` + i + ">.");
13293
12543
  } finally {
13294
12544
  x.H = o;
13295
12545
  }
13296
- }, useReducer: function(e, n, o) {
13297
- z = "useReducer", D(), N();
13298
- var i = x.H;
13299
- x.H = $o;
12546
+ }, useReducer: function(e, n, o) {
12547
+ z = "useReducer", D(), N();
12548
+ var i = x.H;
12549
+ x.H = $o;
12550
+ try {
12551
+ return Br(e, n, o);
12552
+ } finally {
12553
+ x.H = i;
12554
+ }
12555
+ }, useRef: function() {
12556
+ return z = "useRef", D(), N(), xe().memoizedState;
12557
+ }, useState: function() {
12558
+ z = "useState", D(), N();
12559
+ var e = x.H;
12560
+ x.H = $o;
12561
+ try {
12562
+ return Br(gr);
12563
+ } finally {
12564
+ x.H = e;
12565
+ }
12566
+ }, useDebugValue: function() {
12567
+ z = "useDebugValue", D(), N();
12568
+ }, useDeferredValue: function(e, n) {
12569
+ return z = "useDeferredValue", D(), N(), nc(e, n);
12570
+ }, useTransition: function() {
12571
+ return z = "useTransition", D(), N(), Qp();
12572
+ }, useSyncExternalStore: function(e, n, o) {
12573
+ return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
12574
+ }, useId: function() {
12575
+ return z = "useId", D(), N(), xe().memoizedState;
12576
+ }, useFormState: function(e) {
12577
+ return z = "useFormState", D(), N(), hs(e);
12578
+ }, useActionState: function(e) {
12579
+ return z = "useActionState", D(), N(), hs(e);
12580
+ }, useOptimistic: function(e, n) {
12581
+ return z = "useOptimistic", D(), N(), rf(e, n);
12582
+ }, useMemoCache: function(e) {
12583
+ return D(), Oa(e);
12584
+ }, useHostTransitionStatus: ia, useCacheRefresh: function() {
12585
+ return z = "useCacheRefresh", N(), xe().memoizedState;
12586
+ }, useEffectEvent: function(e) {
12587
+ return z = "useEffectEvent", D(), N(), oa(e);
12588
+ } }, dm = { readContext: function(e) {
12589
+ return Ce(), Ee(e);
12590
+ }, use: function(e) {
12591
+ return D(), we(e);
12592
+ }, useCallback: function(e, n) {
12593
+ return z = "useCallback", D(), N(), Ma(e, n);
12594
+ }, useContext: function(e) {
12595
+ return z = "useContext", D(), N(), Ee(e);
12596
+ }, useEffect: function(e, n) {
12597
+ z = "useEffect", D(), N(), Qn(2048, Ut, e, n);
12598
+ }, useImperativeHandle: function(e, n, o) {
12599
+ return z = "useImperativeHandle", D(), N(), aa(e, n, o);
12600
+ }, useInsertionEffect: function(e, n) {
12601
+ return z = "useInsertionEffect", D(), N(), Qn(4, Wt, e, n);
12602
+ }, useLayoutEffect: function(e, n) {
12603
+ return z = "useLayoutEffect", D(), N(), Qn(4, Rr, e, n);
12604
+ }, useMemo: function(e, n) {
12605
+ z = "useMemo", D(), N();
12606
+ var o = x.H;
12607
+ x.H = $o;
12608
+ try {
12609
+ return Vi(e, n);
12610
+ } finally {
12611
+ x.H = o;
12612
+ }
12613
+ }, useReducer: function(e, n, o) {
12614
+ z = "useReducer", D(), N();
12615
+ var i = x.H;
12616
+ x.H = $o;
12617
+ try {
12618
+ return Qi(e, n, o);
12619
+ } finally {
12620
+ x.H = i;
12621
+ }
12622
+ }, useRef: function() {
12623
+ return z = "useRef", D(), N(), xe().memoizedState;
12624
+ }, useState: function() {
12625
+ z = "useState", D(), N();
12626
+ var e = x.H;
12627
+ x.H = $o;
12628
+ try {
12629
+ return Qi(gr);
12630
+ } finally {
12631
+ x.H = e;
12632
+ }
12633
+ }, useDebugValue: function() {
12634
+ z = "useDebugValue", D(), N();
12635
+ }, useDeferredValue: function(e, n) {
12636
+ return z = "useDeferredValue", D(), N(), sf(e, n);
12637
+ }, useTransition: function() {
12638
+ return z = "useTransition", D(), N(), Ro();
12639
+ }, useSyncExternalStore: function(e, n, o) {
12640
+ return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
12641
+ }, useId: function() {
12642
+ return z = "useId", D(), N(), xe().memoizedState;
12643
+ }, useFormState: function(e) {
12644
+ return z = "useFormState", D(), N(), $t(e);
12645
+ }, useActionState: function(e) {
12646
+ return z = "useActionState", D(), N(), $t(e);
12647
+ }, useOptimistic: function(e, n) {
12648
+ return z = "useOptimistic", D(), N(), of(e, n);
12649
+ }, useMemoCache: function(e) {
12650
+ return D(), Oa(e);
12651
+ }, useHostTransitionStatus: ia, useCacheRefresh: function() {
12652
+ return z = "useCacheRefresh", N(), xe().memoizedState;
12653
+ }, useEffectEvent: function(e) {
12654
+ return z = "useEffectEvent", D(), N(), oa(e);
12655
+ } };
12656
+ var Fy = {}, Hy = /* @__PURE__ */ new Set(), Ay = /* @__PURE__ */ new Set(), jy = /* @__PURE__ */ new Set(), Dy = /* @__PURE__ */ new Set(), Wy = /* @__PURE__ */ new Set(), Uy = /* @__PURE__ */ new Set(), By = /* @__PURE__ */ new Set(), Oy = /* @__PURE__ */ new Set(), My = /* @__PURE__ */ new Set(), Qy = /* @__PURE__ */ new Set();
12657
+ Object.freeze(Fy);
12658
+ var zg = { enqueueSetState: function(e, n, o) {
12659
+ e = e._reactInternals;
12660
+ var i = Nt(e), s = zo(i);
12661
+ s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.setState()", e), We(n, e, i), Bi(n, e, i));
12662
+ }, enqueueReplaceState: function(e, n, o) {
12663
+ e = e._reactInternals;
12664
+ var i = Nt(e), s = zo(i);
12665
+ s.tag = Cy, s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.replaceState()", e), We(n, e, i), Bi(n, e, i));
12666
+ }, enqueueForceUpdate: function(e, n) {
12667
+ e = e._reactInternals;
12668
+ var o = Nt(e), i = zo(o);
12669
+ i.tag = Ty, n != null && (df(n), i.callback = n), n = Mt(e, i, o), n !== null && (ur(o, "this.forceUpdate()", e), We(n, e, o), Bi(n, e, o));
12670
+ } }, bd = null, Cg = null, Tg = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."), Cn = false, $y = {}, Vy = {}, qy = {}, Gy = {}, vd = false, Jy = {}, fm = {}, _g = { dehydrated: null, treeContext: null, retryLane: 0, hydrationErrors: null }, Zy = false, Yy = null;
12671
+ Yy = /* @__PURE__ */ new Set();
12672
+ var Si = false, Tn = false, Rg = false, Xy = typeof WeakSet == "function" ? WeakSet : Set, Gn = null, Sd = null, kd = null, _n = null, nr = false, Vo = null, Wn = false, wd = 8192, Vb = { getCacheForType: function(e) {
12673
+ var n = Ee(un), o = n.data.get(e);
12674
+ return o === void 0 && (o = e(), n.data.set(e, o)), o;
12675
+ }, cacheSignal: function() {
12676
+ return Ee(un).controller.signal;
12677
+ }, getOwner: function() {
12678
+ return di;
12679
+ } }, pm = 0, hm = 1, mm = 2, gm = 3, ym = 4;
12680
+ if (typeof Symbol == "function" && Symbol.for) {
12681
+ var bp = Symbol.for;
12682
+ pm = bp("selector.component"), hm = bp("selector.has_pseudo_class"), mm = bp("selector.role"), gm = bp("selector.test_id"), ym = bp("selector.text");
12683
+ }
12684
+ var bm = [], qb = typeof WeakMap == "function" ? WeakMap : Map, Jn = 0, Zn = 2, uo = 4, ki = 0, vp = 1, iu = 2, vm = 3, Tl = 4, Sm = 6, Ky = 5, ye = Jn, je = null, se = null, ae = 0, tr = 0, km = 1, lu = 2, Sp = 3, eb = 4, Eg = 5, kp = 6, wm = 7, Ig = 8, su = 9, Le = tr, Er = null, _l = false, Pd = false, Lg = false, Ta = 0, nn = ki, Rl = 0, El = 0, Ng = 0, rr = 0, uu = 0, wp = null, Bt = null, Pm = false, xm = 0, nb = 0, tb = 300, Pp = 1 / 0, Fg = 500, xp = null, gn = null, Il = null, zm = 0, Hg = 1, Ag = 2, rb = 3, Ll = 0, ob = 1, ab = 2, ib = 3, lb = 4, Cm = 5, Rn = 0, Nl = null, xd = null, qo = 0, jg = 0, Dg = -0, Wg = null, sb = null, ub = null, Go = zm, cb = null, Gb = 50, zp = 0, Ug = null, Bg = false, Tm = false, Jb = 50, cu = 0, Cp = null, zd = false, _m = null, db = false, fb = /* @__PURE__ */ new Set(), Zb = {}, co = null, Cd = null, pb = false;
12685
+ try {
12686
+ var o0 = Object.preventExtensions({});
12687
+ } catch {
12688
+ pb = true;
12689
+ }
12690
+ var hb = false, mb = {}, gb = null, yb = null, bb = null, vb = null, Sb = null, kb = null, wb = null, Pb = null, xb = null, zb = null;
12691
+ return gb = function(e, n, o, i) {
12692
+ n = Yn(e, n), n !== null && (o = _d(n.memoizedState, o, 0, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12693
+ }, yb = function(e, n, o) {
12694
+ n = Yn(e, n), n !== null && (o = du(n.memoizedState, o, 0), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12695
+ }, bb = function(e, n, o, i) {
12696
+ n = Yn(e, n), n !== null && (o = F(n.memoizedState, o, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12697
+ }, vb = function(e, n, o) {
12698
+ e.pendingProps = _d(e.memoizedProps, n, 0, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12699
+ }, Sb = function(e, n) {
12700
+ e.pendingProps = du(e.memoizedProps, n, 0), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12701
+ }, kb = function(e, n, o) {
12702
+ e.pendingProps = F(e.memoizedProps, n, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12703
+ }, wb = function(e) {
12704
+ var n = On(e, 2);
12705
+ n !== null && We(n, e, 2);
12706
+ }, Pb = function(e) {
12707
+ var n = ut(), o = On(e, n);
12708
+ o !== null && We(o, e, n);
12709
+ }, xb = function(e) {
12710
+ pu = e;
12711
+ }, zb = function(e) {
12712
+ fu = e;
12713
+ }, le.attemptContinuousHydration = function(e) {
12714
+ if (e.tag === 13 || e.tag === 31) {
12715
+ var n = On(e, 67108864);
12716
+ n !== null && We(n, e, 67108864), rl(e, 67108864);
12717
+ }
12718
+ }, le.attemptHydrationAtCurrentPriority = function(e) {
12719
+ if (e.tag === 13 || e.tag === 31) {
12720
+ var n = Nt(e);
12721
+ n = Xo(n);
12722
+ var o = On(e, n);
12723
+ o !== null && We(o, e, n), rl(e, n);
12724
+ }
12725
+ }, le.attemptSynchronousHydration = function(e) {
12726
+ switch (e.tag) {
12727
+ case 3:
12728
+ if (e = e.stateNode, e.current.memoizedState.isDehydrated) {
12729
+ var n = _t(e.pendingLanes);
12730
+ if (n !== 0) {
12731
+ for (e.pendingLanes |= 2, e.entangledLanes |= 2; n; ) {
12732
+ var o = 1 << 31 - vn(n);
12733
+ e.entanglements[1] |= o, n &= ~o;
12734
+ }
12735
+ Kn(e), (ye & (Zn | uo)) === Jn && (Pp = me() + Fg, Wa(0));
12736
+ }
12737
+ }
12738
+ break;
12739
+ case 31:
12740
+ case 13:
12741
+ n = On(e, 2), n !== null && We(n, e, 2), Ls(), rl(e, 2);
12742
+ }
12743
+ }, le.batchedUpdates = function(e, n) {
12744
+ return e(n);
12745
+ }, le.createComponentSelector = function(e) {
12746
+ return { $$typeof: pm, value: e };
12747
+ }, le.createContainer = function(e, n, o, i, s, u, f, p, g, S) {
12748
+ return Ka(e, n, false, null, o, i, u, null, f, p, g, S);
12749
+ }, le.createHasPseudoClassSelector = function(e) {
12750
+ return { $$typeof: hm, value: e };
12751
+ }, le.createHydrationContainer = function(e, n, o, i, s, u, f, p, g, S, T, _, I, O) {
12752
+ return e = Ka(o, i, true, e, s, u, p, O, g, S, T, _), e.context = Dh(null), o = e.current, i = Nt(o), i = Xo(i), s = zo(i), s.callback = n ?? null, Mt(o, s, i), ur(i, "hydrateRoot()", null), n = i, e.current.lanes = n, Ci(e, n), Kn(e), e;
12753
+ }, le.createPortal = function(e, n, o) {
12754
+ var i = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
13300
12755
  try {
13301
- return Br(e, n, o);
13302
- } finally {
13303
- x.H = i;
12756
+ vt(i);
12757
+ var s = false;
12758
+ } catch {
12759
+ s = true;
13304
12760
  }
13305
- }, useRef: function() {
13306
- return z = "useRef", D(), N(), xe().memoizedState;
13307
- }, useState: function() {
13308
- z = "useState", D(), N();
13309
- var e = x.H;
13310
- x.H = $o;
12761
+ return s && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", typeof Symbol == "function" && Symbol.toStringTag && i[Symbol.toStringTag] || i.constructor.name || "Object"), vt(i)), { $$typeof: Ao, key: i == null ? null : "" + i, children: e, containerInfo: n, implementation: o };
12762
+ }, le.createRoleSelector = function(e) {
12763
+ return { $$typeof: mm, value: e };
12764
+ }, le.createTestNameSelector = function(e) {
12765
+ return { $$typeof: gm, value: e };
12766
+ }, le.createTextSelector = function(e) {
12767
+ return { $$typeof: ym, value: e };
12768
+ }, le.defaultOnCaughtError = function(e) {
12769
+ var n = bd ? "The above error occurred in the <" + bd + "> component." : "The above error occurred in one of your React components.", o = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((Cg || "Anonymous") + ".");
12770
+ typeof e == "object" && e !== null && typeof e.environmentName == "string" ? ri("error", [`%o
12771
+
12772
+ %s
12773
+
12774
+ %s
12775
+ `, e, n, o], e.environmentName)() : console.error(`%o
12776
+
12777
+ %s
12778
+
12779
+ %s
12780
+ `, e, n, o);
12781
+ }, le.defaultOnRecoverableError = function(e) {
12782
+ qg(e);
12783
+ }, le.defaultOnUncaughtError = function(e) {
12784
+ qg(e), console.warn(`%s
12785
+
12786
+ %s
12787
+ `, bd ? "An error occurred in the <" + bd + "> component." : "An error occurred in one of your React components.", `Consider adding an error boundary to your tree to customize error handling behavior.
12788
+ Visit https://react.dev/link/error-boundaries to learn more about error boundaries.`);
12789
+ }, le.deferredUpdates = function(e) {
12790
+ var n = x.T, o = wt();
13311
12791
  try {
13312
- return Br(gr);
12792
+ return an(32), x.T = null, e();
13313
12793
  } finally {
13314
- x.H = e;
12794
+ an(o), x.T = n;
13315
12795
  }
13316
- }, useDebugValue: function() {
13317
- z = "useDebugValue", D(), N();
13318
- }, useDeferredValue: function(e, n) {
13319
- return z = "useDeferredValue", D(), N(), nc(e, n);
13320
- }, useTransition: function() {
13321
- return z = "useTransition", D(), N(), Qp();
13322
- }, useSyncExternalStore: function(e, n, o) {
13323
- return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
13324
- }, useId: function() {
13325
- return z = "useId", D(), N(), xe().memoizedState;
13326
- }, useFormState: function(e) {
13327
- return z = "useFormState", D(), N(), hs(e);
13328
- }, useActionState: function(e) {
13329
- return z = "useActionState", D(), N(), hs(e);
13330
- }, useOptimistic: function(e, n) {
13331
- return z = "useOptimistic", D(), N(), rf(e, n);
13332
- }, useMemoCache: function(e) {
13333
- return D(), Oa(e);
13334
- }, useHostTransitionStatus: ia, useCacheRefresh: function() {
13335
- return z = "useCacheRefresh", N(), xe().memoizedState;
13336
- }, useEffectEvent: function(e) {
13337
- return z = "useEffectEvent", D(), N(), oa(e);
13338
- } }, dm = { readContext: function(e) {
13339
- return Ce(), Ee(e);
13340
- }, use: function(e) {
13341
- return D(), we(e);
13342
- }, useCallback: function(e, n) {
13343
- return z = "useCallback", D(), N(), Ma(e, n);
13344
- }, useContext: function(e) {
13345
- return z = "useContext", D(), N(), Ee(e);
13346
- }, useEffect: function(e, n) {
13347
- z = "useEffect", D(), N(), Qn(2048, Ut, e, n);
13348
- }, useImperativeHandle: function(e, n, o) {
13349
- return z = "useImperativeHandle", D(), N(), aa(e, n, o);
13350
- }, useInsertionEffect: function(e, n) {
13351
- return z = "useInsertionEffect", D(), N(), Qn(4, Wt, e, n);
13352
- }, useLayoutEffect: function(e, n) {
13353
- return z = "useLayoutEffect", D(), N(), Qn(4, Rr, e, n);
13354
- }, useMemo: function(e, n) {
13355
- z = "useMemo", D(), N();
13356
- var o = x.H;
13357
- x.H = $o;
12796
+ }, le.discreteUpdates = function(e, n, o, i, s) {
12797
+ var u = x.T, f = wt();
13358
12798
  try {
13359
- return Vi(e, n);
12799
+ return an(2), x.T = null, e(n, o, i, s);
13360
12800
  } finally {
13361
- x.H = o;
12801
+ an(f), x.T = u, ye === Jn && (Pp = me() + Fg);
13362
12802
  }
13363
- }, useReducer: function(e, n, o) {
13364
- z = "useReducer", D(), N();
13365
- var i = x.H;
13366
- x.H = $o;
13367
- try {
13368
- return Qi(e, n, o);
13369
- } finally {
13370
- x.H = i;
12803
+ }, le.findAllNodes = kc, le.findBoundingRects = function(e, n) {
12804
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12805
+ n = kc(e, n), e = [];
12806
+ for (var o = 0; o < n.length; o++) e.push(ma(n[o]));
12807
+ for (n = e.length - 1; 0 < n; n--) {
12808
+ o = e[n];
12809
+ for (var i = o.x, s = i + o.width, u = o.y, f = u + o.height, p = n - 1; 0 <= p; p--) if (n !== p) {
12810
+ var g = e[p], S = g.x, T = S + g.width, _ = g.y, I = _ + g.height;
12811
+ if (i >= S && u >= _ && s <= T && f <= I) {
12812
+ e.splice(n, 1);
12813
+ break;
12814
+ } else if (i !== S || o.width !== g.width || I < u || _ > f) {
12815
+ if (!(u !== _ || o.height !== g.height || T < i || S > s)) {
12816
+ S > i && (g.width += S - i, g.x = i), T < s && (g.width = s - S), e.splice(n, 1);
12817
+ break;
12818
+ }
12819
+ } else {
12820
+ _ > u && (g.height += _ - u, g.y = u), I < f && (g.height = f - _), e.splice(n, 1);
12821
+ break;
12822
+ }
12823
+ }
13371
12824
  }
13372
- }, useRef: function() {
13373
- return z = "useRef", D(), N(), xe().memoizedState;
13374
- }, useState: function() {
13375
- z = "useState", D(), N();
13376
- var e = x.H;
13377
- x.H = $o;
12825
+ return e;
12826
+ }, le.findHostInstance = function(e) {
12827
+ var n = e._reactInternals;
12828
+ if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
12829
+ return e = mu(n), e === null ? null : ot(e.stateNode);
12830
+ }, le.findHostInstanceWithNoPortals = function(e) {
12831
+ return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
12832
+ }, le.findHostInstanceWithWarning = function(e, n) {
12833
+ var o = e._reactInternals;
12834
+ if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
12835
+ if (e = mu(o), e === null) return null;
12836
+ if (e.mode & 8) {
12837
+ var i = G(o) || "Component";
12838
+ mb[i] || (mb[i] = true, B(e, function() {
12839
+ o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
12840
+ }));
12841
+ }
12842
+ return ot(e.stateNode);
12843
+ }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
12844
+ var n = ye;
12845
+ ye |= 1;
12846
+ var o = x.T, i = wt();
13378
12847
  try {
13379
- return Qi(gr);
12848
+ if (an(2), x.T = null, e) return e();
13380
12849
  } finally {
13381
- x.H = e;
12850
+ an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
12851
+ }
12852
+ }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
12853
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12854
+ for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
12855
+ var o = n[e++], i = o.tag;
12856
+ if (!Kr(o)) {
12857
+ if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
12858
+ for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
12859
+ }
12860
+ }
12861
+ return false;
12862
+ }, le.getFindAllNodesFailureDescription = function(e, n) {
12863
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12864
+ var o = 0, i = [];
12865
+ e = [Ef(e), 0];
12866
+ for (var s = 0; s < e.length; ) {
12867
+ var u = e[s++], f = u.tag, p = e[s++], g = n[p];
12868
+ if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
12869
+ }
12870
+ if (o < n.length) {
12871
+ for (e = []; o < n.length; o++) e.push(Sc(n[o]));
12872
+ return `findAllNodes was able to match part of the selector:
12873
+ ` + (i.join(" > ") + `
12874
+
12875
+ No matching component was found for:
12876
+ `) + e.join(" > ");
12877
+ }
12878
+ return null;
12879
+ }, le.getPublicRootInstance = function(e) {
12880
+ if (e = e.current, !e.child) return null;
12881
+ switch (e.child.tag) {
12882
+ case 27:
12883
+ case 5:
12884
+ return ot(e.child.stateNode);
12885
+ default:
12886
+ return e.child.stateNode;
12887
+ }
12888
+ }, le.injectIntoDevTools = function() {
12889
+ var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
12890
+ return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
12891
+ }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
12892
+ function s() {
12893
+ var S = kc(e, n);
12894
+ u.forEach(function(T) {
12895
+ 0 > S.indexOf(T) && g(T);
12896
+ }), S.forEach(function(T) {
12897
+ 0 > u.indexOf(T) && p(T);
12898
+ });
12899
+ }
12900
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12901
+ var u = kc(e, n);
12902
+ o = zr(u, o, i);
12903
+ var f = o.disconnect, p = o.observe, g = o.unobserve;
12904
+ return bm.push(s), { disconnect: function() {
12905
+ var S = bm.indexOf(s);
12906
+ 0 <= S && bm.splice(S, 1), f();
12907
+ } };
12908
+ }, le.shouldError = function(e) {
12909
+ return pu(e);
12910
+ }, le.shouldSuspend = function(e) {
12911
+ return fu(e);
12912
+ }, le.startHostTransition = function(e, n, o, i) {
12913
+ if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
12914
+ var s = uf(e).queue;
12915
+ Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
12916
+ x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
12917
+ var u = uf(e);
12918
+ return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
12919
+ });
12920
+ }, le.updateContainer = function(e, n, o, i) {
12921
+ var s = n.current, u = Nt(s);
12922
+ return As(s, u, e, n, o, i), u;
12923
+ }, le.updateContainerSync = Wh, le;
12924
+ }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
12925
+ })(Mg)), Mg.exports;
12926
+ }
12927
+ var Eb;
12928
+ function n0() {
12929
+ return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
12930
+ }
12931
+ var t0 = n0();
12932
+ const r0 = Xb(t0);
12933
+
12934
+ const DEFAULT_POINTER_ID = 0;
12935
+ const XR_POINTER_ID_START = 1e3;
12936
+ function getPointerState(internal, pointerId) {
12937
+ let state = internal.pointerMap.get(pointerId);
12938
+ if (!state) {
12939
+ state = {
12940
+ hovered: /* @__PURE__ */ new Map(),
12941
+ captured: /* @__PURE__ */ new Map(),
12942
+ initialClick: [0, 0],
12943
+ initialHits: []
12944
+ };
12945
+ internal.pointerMap.set(pointerId, state);
12946
+ }
12947
+ return state;
12948
+ }
12949
+ function getPointerId(event) {
12950
+ return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
12951
+ }
12952
+ function makeId(event) {
12953
+ return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
12954
+ }
12955
+ function releaseInternalPointerCapture(internal, obj, pointerId) {
12956
+ const pointerState = internal.pointerMap.get(pointerId);
12957
+ if (!pointerState) return;
12958
+ const captureData = pointerState.captured.get(obj);
12959
+ if (captureData) {
12960
+ pointerState.captured.delete(obj);
12961
+ try {
12962
+ captureData.target.releasePointerCapture?.(pointerId);
12963
+ } catch {
12964
+ }
12965
+ }
12966
+ }
12967
+ function swapInteractivity(store, object, newObject) {
12968
+ const { internal } = store.getState();
12969
+ for (let i = 0; i < internal.interaction.length; i++) {
12970
+ if (internal.interaction[i] === object) internal.interaction[i] = newObject;
12971
+ }
12972
+ for (const pointerState of internal.pointerMap.values()) {
12973
+ for (let i = 0; i < pointerState.initialHits.length; i++) {
12974
+ if (pointerState.initialHits[i] === object) pointerState.initialHits[i] = newObject;
12975
+ }
12976
+ pointerState.hovered.forEach((value, key) => {
12977
+ if (value.eventObject === object || value.object === object) {
12978
+ pointerState.hovered.delete(key);
12979
+ const next = {
12980
+ ...value,
12981
+ eventObject: value.eventObject === object ? newObject : value.eventObject,
12982
+ object: value.object === object ? newObject : value.object
12983
+ };
12984
+ pointerState.hovered.set(makeId(next), next);
12985
+ }
12986
+ });
12987
+ const captureData = pointerState.captured.get(object);
12988
+ if (captureData) {
12989
+ pointerState.captured.delete(object);
12990
+ pointerState.captured.set(newObject, {
12991
+ ...captureData,
12992
+ intersection: {
12993
+ ...captureData.intersection,
12994
+ object: captureData.intersection.object === object ? newObject : captureData.intersection.object,
12995
+ eventObject: captureData.intersection.eventObject === object ? newObject : captureData.intersection.eventObject
13382
12996
  }
13383
- }, useDebugValue: function() {
13384
- z = "useDebugValue", D(), N();
13385
- }, useDeferredValue: function(e, n) {
13386
- return z = "useDeferredValue", D(), N(), sf(e, n);
13387
- }, useTransition: function() {
13388
- return z = "useTransition", D(), N(), Ro();
13389
- }, useSyncExternalStore: function(e, n, o) {
13390
- return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
13391
- }, useId: function() {
13392
- return z = "useId", D(), N(), xe().memoizedState;
13393
- }, useFormState: function(e) {
13394
- return z = "useFormState", D(), N(), $t(e);
13395
- }, useActionState: function(e) {
13396
- return z = "useActionState", D(), N(), $t(e);
13397
- }, useOptimistic: function(e, n) {
13398
- return z = "useOptimistic", D(), N(), of(e, n);
13399
- }, useMemoCache: function(e) {
13400
- return D(), Oa(e);
13401
- }, useHostTransitionStatus: ia, useCacheRefresh: function() {
13402
- return z = "useCacheRefresh", N(), xe().memoizedState;
13403
- }, useEffectEvent: function(e) {
13404
- return z = "useEffectEvent", D(), N(), oa(e);
13405
- } };
13406
- var Fy = {}, Hy = /* @__PURE__ */ new Set(), Ay = /* @__PURE__ */ new Set(), jy = /* @__PURE__ */ new Set(), Dy = /* @__PURE__ */ new Set(), Wy = /* @__PURE__ */ new Set(), Uy = /* @__PURE__ */ new Set(), By = /* @__PURE__ */ new Set(), Oy = /* @__PURE__ */ new Set(), My = /* @__PURE__ */ new Set(), Qy = /* @__PURE__ */ new Set();
13407
- Object.freeze(Fy);
13408
- var zg = { enqueueSetState: function(e, n, o) {
13409
- e = e._reactInternals;
13410
- var i = Nt(e), s = zo(i);
13411
- s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.setState()", e), We(n, e, i), Bi(n, e, i));
13412
- }, enqueueReplaceState: function(e, n, o) {
13413
- e = e._reactInternals;
13414
- var i = Nt(e), s = zo(i);
13415
- s.tag = Cy, s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.replaceState()", e), We(n, e, i), Bi(n, e, i));
13416
- }, enqueueForceUpdate: function(e, n) {
13417
- e = e._reactInternals;
13418
- var o = Nt(e), i = zo(o);
13419
- i.tag = Ty, n != null && (df(n), i.callback = n), n = Mt(e, i, o), n !== null && (ur(o, "this.forceUpdate()", e), We(n, e, o), Bi(n, e, o));
13420
- } }, bd = null, Cg = null, Tg = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."), Cn = false, $y = {}, Vy = {}, qy = {}, Gy = {}, vd = false, Jy = {}, fm = {}, _g = { dehydrated: null, treeContext: null, retryLane: 0, hydrationErrors: null }, Zy = false, Yy = null;
13421
- Yy = /* @__PURE__ */ new Set();
13422
- var Si = false, Tn = false, Rg = false, Xy = typeof WeakSet == "function" ? WeakSet : Set, Gn = null, Sd = null, kd = null, _n = null, nr = false, Vo = null, Wn = false, wd = 8192, Vb = { getCacheForType: function(e) {
13423
- var n = Ee(un), o = n.data.get(e);
13424
- return o === void 0 && (o = e(), n.data.set(e, o)), o;
13425
- }, cacheSignal: function() {
13426
- return Ee(un).controller.signal;
13427
- }, getOwner: function() {
13428
- return di;
13429
- } }, pm = 0, hm = 1, mm = 2, gm = 3, ym = 4;
13430
- if (typeof Symbol == "function" && Symbol.for) {
13431
- var bp = Symbol.for;
13432
- pm = bp("selector.component"), hm = bp("selector.has_pseudo_class"), mm = bp("selector.role"), gm = bp("selector.test_id"), ym = bp("selector.text");
12997
+ });
12998
+ }
12999
+ }
13000
+ unregisterVisibility(store, object);
13001
+ }
13002
+ function removeInteractivity(store, object) {
13003
+ const { internal } = store.getState();
13004
+ internal.interaction = internal.interaction.filter((o) => o !== object);
13005
+ for (const [pointerId, pointerState] of internal.pointerMap) {
13006
+ pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
13007
+ pointerState.hovered.forEach((value, key) => {
13008
+ if (value.eventObject === object || value.object === object) {
13009
+ pointerState.hovered.delete(key);
13433
13010
  }
13434
- var bm = [], qb = typeof WeakMap == "function" ? WeakMap : Map, Jn = 0, Zn = 2, uo = 4, ki = 0, vp = 1, iu = 2, vm = 3, Tl = 4, Sm = 6, Ky = 5, ye = Jn, je = null, se = null, ae = 0, tr = 0, km = 1, lu = 2, Sp = 3, eb = 4, Eg = 5, kp = 6, wm = 7, Ig = 8, su = 9, Le = tr, Er = null, _l = false, Pd = false, Lg = false, Ta = 0, nn = ki, Rl = 0, El = 0, Ng = 0, rr = 0, uu = 0, wp = null, Bt = null, Pm = false, xm = 0, nb = 0, tb = 300, Pp = 1 / 0, Fg = 500, xp = null, gn = null, Il = null, zm = 0, Hg = 1, Ag = 2, rb = 3, Ll = 0, ob = 1, ab = 2, ib = 3, lb = 4, Cm = 5, Rn = 0, Nl = null, xd = null, qo = 0, jg = 0, Dg = -0, Wg = null, sb = null, ub = null, Go = zm, cb = null, Gb = 50, zp = 0, Ug = null, Bg = false, Tm = false, Jb = 50, cu = 0, Cp = null, zd = false, _m = null, db = false, fb = /* @__PURE__ */ new Set(), Zb = {}, co = null, Cd = null, pb = false;
13435
- try {
13436
- var o0 = Object.preventExtensions({});
13437
- } catch {
13438
- pb = true;
13011
+ });
13012
+ if (pointerState.captured.has(object)) {
13013
+ releaseInternalPointerCapture(internal, object, pointerId);
13014
+ }
13015
+ }
13016
+ unregisterVisibility(store, object);
13017
+ }
13018
+ function createEvents(store) {
13019
+ function calculateDistance(event, pointerId) {
13020
+ const { internal } = store.getState();
13021
+ const pointerState = internal.pointerMap.get(pointerId);
13022
+ if (!pointerState) return 0;
13023
+ const [initialX, initialY] = pointerState.initialClick;
13024
+ const dx = event.offsetX - initialX;
13025
+ const dy = event.offsetY - initialY;
13026
+ return Math.round(Math.sqrt(dx * dx + dy * dy));
13027
+ }
13028
+ function filterPointerEvents(objects) {
13029
+ return objects.filter(
13030
+ (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
13031
+ (name) => obj.__r3f?.handlers["onPointer" + name]
13032
+ ) || ["OverEnter", "OverLeave", "Over"].some(
13033
+ (name) => obj.__r3f?.handlers["onDrag" + name]
13034
+ ) || obj.__r3f?.handlers.onDrop
13035
+ );
13036
+ }
13037
+ function intersect(event, filter) {
13038
+ const state = store.getState();
13039
+ const duplicates = /* @__PURE__ */ new Set();
13040
+ const intersections = [];
13041
+ const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
13042
+ for (let i = 0; i < eventsObjects.length; i++) {
13043
+ const state2 = getRootState(eventsObjects[i]);
13044
+ if (state2) {
13045
+ state2.raycaster.camera = void 0;
13439
13046
  }
13440
- var hb = false, mb = {}, gb = null, yb = null, bb = null, vb = null, Sb = null, kb = null, wb = null, Pb = null, xb = null, zb = null;
13441
- return gb = function(e, n, o, i) {
13442
- n = Yn(e, n), n !== null && (o = _d(n.memoizedState, o, 0, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13443
- }, yb = function(e, n, o) {
13444
- n = Yn(e, n), n !== null && (o = du(n.memoizedState, o, 0), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13445
- }, bb = function(e, n, o, i) {
13446
- n = Yn(e, n), n !== null && (o = F(n.memoizedState, o, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13447
- }, vb = function(e, n, o) {
13448
- e.pendingProps = _d(e.memoizedProps, n, 0, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13449
- }, Sb = function(e, n) {
13450
- e.pendingProps = du(e.memoizedProps, n, 0), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13451
- }, kb = function(e, n, o) {
13452
- e.pendingProps = F(e.memoizedProps, n, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13453
- }, wb = function(e) {
13454
- var n = On(e, 2);
13455
- n !== null && We(n, e, 2);
13456
- }, Pb = function(e) {
13457
- var n = ut(), o = On(e, n);
13458
- o !== null && We(o, e, n);
13459
- }, xb = function(e) {
13460
- pu = e;
13461
- }, zb = function(e) {
13462
- fu = e;
13463
- }, le.attemptContinuousHydration = function(e) {
13464
- if (e.tag === 13 || e.tag === 31) {
13465
- var n = On(e, 67108864);
13466
- n !== null && We(n, e, 67108864), rl(e, 67108864);
13047
+ }
13048
+ if (!state.previousRoot) {
13049
+ state.events.compute?.(event, state);
13050
+ }
13051
+ function handleRaycast(obj) {
13052
+ const state2 = getRootState(obj);
13053
+ if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
13054
+ if (state2.raycaster.camera === void 0) {
13055
+ state2.events.compute?.(event, state2, state2.previousRoot?.getState());
13056
+ if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
13057
+ }
13058
+ if (!state2.raycaster.camera) return [];
13059
+ obj.updateWorldMatrix(true, true);
13060
+ return state2.raycaster.intersectObject(obj, true);
13061
+ }
13062
+ let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
13063
+ const aInteractivePriority = a.object.userData?.interactivePriority;
13064
+ const bInteractivePriority = b.object.userData?.interactivePriority;
13065
+ if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
13066
+ if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
13067
+ if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
13068
+ if (aInteractivePriority !== bInteractivePriority) {
13069
+ return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
13467
13070
  }
13468
- }, le.attemptHydrationAtCurrentPriority = function(e) {
13469
- if (e.tag === 13 || e.tag === 31) {
13470
- var n = Nt(e);
13471
- n = Xo(n);
13472
- var o = On(e, n);
13473
- o !== null && We(o, e, n), rl(e, n);
13071
+ }
13072
+ const aState = getRootState(a.object);
13073
+ const bState = getRootState(b.object);
13074
+ const aPriority = aState?.events?.priority ?? 1;
13075
+ const bPriority = bState?.events?.priority ?? 1;
13076
+ return bPriority - aPriority || a.distance - b.distance;
13077
+ }).filter((item) => {
13078
+ const id = makeId(item);
13079
+ if (duplicates.has(id)) return false;
13080
+ duplicates.add(id);
13081
+ return true;
13082
+ });
13083
+ if (state.events.filter) hits = state.events.filter(hits, state);
13084
+ for (const hit of hits) {
13085
+ let eventObject = hit.object;
13086
+ while (eventObject) {
13087
+ if (eventObject.__r3f?.eventCount) {
13088
+ intersections.push({ ...hit, eventObject });
13474
13089
  }
13475
- }, le.attemptSynchronousHydration = function(e) {
13476
- switch (e.tag) {
13477
- case 3:
13478
- if (e = e.stateNode, e.current.memoizedState.isDehydrated) {
13479
- var n = _t(e.pendingLanes);
13480
- if (n !== 0) {
13481
- for (e.pendingLanes |= 2, e.entangledLanes |= 2; n; ) {
13482
- var o = 1 << 31 - vn(n);
13483
- e.entanglements[1] |= o, n &= ~o;
13090
+ eventObject = eventObject.parent;
13091
+ }
13092
+ }
13093
+ if ("pointerId" in event) {
13094
+ const pointerId = event.pointerId;
13095
+ const pointerState = state.internal.pointerMap.get(pointerId);
13096
+ if (pointerState?.captured.size) {
13097
+ for (const captureData of pointerState.captured.values()) {
13098
+ if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
13099
+ }
13100
+ }
13101
+ }
13102
+ return intersections;
13103
+ }
13104
+ function handleIntersects(intersections, event, delta, callback) {
13105
+ if (intersections.length) {
13106
+ const localState = { stopped: false };
13107
+ for (const hit of intersections) {
13108
+ const state = getRootState(hit.object);
13109
+ if (state) {
13110
+ const { raycaster, pointer, camera, internal } = state;
13111
+ const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
13112
+ const hasPointerCapture = (id) => {
13113
+ const pointerState = internal.pointerMap.get(id);
13114
+ return pointerState?.captured.has(hit.eventObject) ?? false;
13115
+ };
13116
+ const setPointerCapture = (id) => {
13117
+ const captureData = { intersection: hit, target: event.target };
13118
+ const pointerState = getPointerState(internal, id);
13119
+ pointerState.captured.set(hit.eventObject, captureData);
13120
+ event.target.setPointerCapture(id);
13121
+ };
13122
+ const releasePointerCapture = (id) => {
13123
+ releaseInternalPointerCapture(internal, hit.eventObject, id);
13124
+ };
13125
+ const extractEventProps = {};
13126
+ for (const prop in event) {
13127
+ const property = event[prop];
13128
+ if (typeof property !== "function") extractEventProps[prop] = property;
13129
+ }
13130
+ const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
13131
+ const raycastEvent = {
13132
+ ...hit,
13133
+ ...extractEventProps,
13134
+ pointer,
13135
+ intersections,
13136
+ stopped: localState.stopped,
13137
+ delta,
13138
+ unprojectedPoint,
13139
+ ray: raycaster.ray,
13140
+ camera,
13141
+ pointerId: eventPointerId,
13142
+ // Hijack stopPropagation, which just sets a flag
13143
+ stopPropagation() {
13144
+ const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
13145
+ if (
13146
+ // ...if this pointer hasn't been captured
13147
+ !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
13148
+ pointerState.captured.has(hit.eventObject)
13149
+ ) {
13150
+ raycastEvent.stopped = localState.stopped = true;
13151
+ if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
13152
+ const higher = intersections.slice(0, intersections.indexOf(hit));
13153
+ cancelPointer([...higher, hit], eventPointerId);
13484
13154
  }
13485
- Kn(e), (ye & (Zn | uo)) === Jn && (Pp = me() + Fg, Wa(0));
13486
13155
  }
13487
- }
13488
- break;
13489
- case 31:
13490
- case 13:
13491
- n = On(e, 2), n !== null && We(n, e, 2), Ls(), rl(e, 2);
13156
+ },
13157
+ // there should be a distinction between target and currentTarget
13158
+ target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
13159
+ currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
13160
+ nativeEvent: event
13161
+ };
13162
+ callback(raycastEvent);
13163
+ if (localState.stopped === true) break;
13492
13164
  }
13493
- }, le.batchedUpdates = function(e, n) {
13494
- return e(n);
13495
- }, le.createComponentSelector = function(e) {
13496
- return { $$typeof: pm, value: e };
13497
- }, le.createContainer = function(e, n, o, i, s, u, f, p, g, S) {
13498
- return Ka(e, n, false, null, o, i, u, null, f, p, g, S);
13499
- }, le.createHasPseudoClassSelector = function(e) {
13500
- return { $$typeof: hm, value: e };
13501
- }, le.createHydrationContainer = function(e, n, o, i, s, u, f, p, g, S, T, _, I, O) {
13502
- return e = Ka(o, i, true, e, s, u, p, O, g, S, T, _), e.context = Dh(null), o = e.current, i = Nt(o), i = Xo(i), s = zo(i), s.callback = n ?? null, Mt(o, s, i), ur(i, "hydrateRoot()", null), n = i, e.current.lanes = n, Ci(e, n), Kn(e), e;
13503
- }, le.createPortal = function(e, n, o) {
13504
- var i = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
13505
- try {
13506
- vt(i);
13507
- var s = false;
13508
- } catch {
13509
- s = true;
13165
+ }
13166
+ }
13167
+ return intersections;
13168
+ }
13169
+ function cancelPointer(intersections, pointerId) {
13170
+ const { internal } = store.getState();
13171
+ const pid = pointerId ?? DEFAULT_POINTER_ID;
13172
+ const pointerState = internal.pointerMap.get(pid);
13173
+ if (!pointerState) return;
13174
+ for (const [hoveredId, hoveredObj] of pointerState.hovered) {
13175
+ if (!intersections.length || !intersections.find(
13176
+ (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
13177
+ )) {
13178
+ const eventObject = hoveredObj.eventObject;
13179
+ const instance = eventObject.__r3f;
13180
+ pointerState.hovered.delete(hoveredId);
13181
+ if (instance?.eventCount) {
13182
+ const handlers = instance.handlers;
13183
+ const data = { ...hoveredObj, intersections };
13184
+ handlers.onPointerOut?.(data);
13185
+ handlers.onPointerLeave?.(data);
13186
+ handlers.onDragOverLeave?.(data);
13510
13187
  }
13511
- return s && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", typeof Symbol == "function" && Symbol.toStringTag && i[Symbol.toStringTag] || i.constructor.name || "Object"), vt(i)), { $$typeof: Ao, key: i == null ? null : "" + i, children: e, containerInfo: n, implementation: o };
13512
- }, le.createRoleSelector = function(e) {
13513
- return { $$typeof: mm, value: e };
13514
- }, le.createTestNameSelector = function(e) {
13515
- return { $$typeof: gm, value: e };
13516
- }, le.createTextSelector = function(e) {
13517
- return { $$typeof: ym, value: e };
13518
- }, le.defaultOnCaughtError = function(e) {
13519
- var n = bd ? "The above error occurred in the <" + bd + "> component." : "The above error occurred in one of your React components.", o = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((Cg || "Anonymous") + ".");
13520
- typeof e == "object" && e !== null && typeof e.environmentName == "string" ? ri("error", [`%o
13521
-
13522
- %s
13523
-
13524
- %s
13525
- `, e, n, o], e.environmentName)() : console.error(`%o
13526
-
13527
- %s
13528
-
13529
- %s
13530
- `, e, n, o);
13531
- }, le.defaultOnRecoverableError = function(e) {
13532
- qg(e);
13533
- }, le.defaultOnUncaughtError = function(e) {
13534
- qg(e), console.warn(`%s
13535
-
13536
- %s
13537
- `, bd ? "An error occurred in the <" + bd + "> component." : "An error occurred in one of your React components.", `Consider adding an error boundary to your tree to customize error handling behavior.
13538
- Visit https://react.dev/link/error-boundaries to learn more about error boundaries.`);
13539
- }, le.deferredUpdates = function(e) {
13540
- var n = x.T, o = wt();
13541
- try {
13542
- return an(32), x.T = null, e();
13543
- } finally {
13544
- an(o), x.T = n;
13188
+ }
13189
+ }
13190
+ }
13191
+ function pointerMissed(event, objects) {
13192
+ for (let i = 0; i < objects.length; i++) {
13193
+ const instance = objects[i].__r3f;
13194
+ instance?.handlers.onPointerMissed?.(event);
13195
+ }
13196
+ }
13197
+ function dragOverMissed(event, objects) {
13198
+ for (let i = 0; i < objects.length; i++) {
13199
+ const instance = objects[i].__r3f;
13200
+ instance?.handlers.onDragOverMissed?.(event);
13201
+ }
13202
+ }
13203
+ function dropMissed(event, objects) {
13204
+ for (let i = 0; i < objects.length; i++) {
13205
+ const instance = objects[i].__r3f;
13206
+ instance?.handlers.onDropMissed?.(event);
13207
+ }
13208
+ }
13209
+ function cleanupPointer(pointerId) {
13210
+ const { internal } = store.getState();
13211
+ const pointerState = internal.pointerMap.get(pointerId);
13212
+ if (pointerState) {
13213
+ for (const [, hoveredObj] of pointerState.hovered) {
13214
+ const eventObject = hoveredObj.eventObject;
13215
+ const instance = eventObject.__r3f;
13216
+ if (instance?.eventCount) {
13217
+ const handlers = instance.handlers;
13218
+ const data = { ...hoveredObj, intersections: [] };
13219
+ handlers.onPointerOut?.(data);
13220
+ handlers.onPointerLeave?.(data);
13545
13221
  }
13546
- }, le.discreteUpdates = function(e, n, o, i, s) {
13547
- var u = x.T, f = wt();
13548
- try {
13549
- return an(2), x.T = null, e(n, o, i, s);
13550
- } finally {
13551
- an(f), x.T = u, ye === Jn && (Pp = me() + Fg);
13222
+ }
13223
+ internal.pointerMap.delete(pointerId);
13224
+ }
13225
+ internal.pointerDirty.delete(pointerId);
13226
+ }
13227
+ function processDeferredPointer(event, pointerId) {
13228
+ const state = store.getState();
13229
+ const { internal } = state;
13230
+ if (!state.events.enabled) return;
13231
+ const filter = filterPointerEvents;
13232
+ const hits = intersect(event, filter);
13233
+ cancelPointer(hits, pointerId);
13234
+ function onIntersect(data) {
13235
+ const eventObject = data.eventObject;
13236
+ const instance = eventObject.__r3f;
13237
+ if (!instance?.eventCount) return;
13238
+ const handlers = instance.handlers;
13239
+ if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
13240
+ const id = makeId(data);
13241
+ const pointerState = getPointerState(internal, pointerId);
13242
+ const hoveredItem = pointerState.hovered.get(id);
13243
+ if (!hoveredItem) {
13244
+ pointerState.hovered.set(id, data);
13245
+ handlers.onPointerOver?.(data);
13246
+ handlers.onPointerEnter?.(data);
13247
+ } else if (hoveredItem.stopped) {
13248
+ data.stopPropagation();
13249
+ }
13250
+ }
13251
+ handlers.onPointerMove?.(data);
13252
+ }
13253
+ handleIntersects(hits, event, 0, onIntersect);
13254
+ }
13255
+ function handlePointer(name) {
13256
+ switch (name) {
13257
+ case "onPointerLeave":
13258
+ case "onDragLeave":
13259
+ return () => cancelPointer([]);
13260
+ // Global cancel of these events
13261
+ case "onPointerCancel":
13262
+ return (event) => {
13263
+ const pointerId = getPointerId(event);
13264
+ cleanupPointer(pointerId);
13265
+ };
13266
+ case "onLostPointerCapture":
13267
+ return (event) => {
13268
+ const { internal } = store.getState();
13269
+ const pointerId = getPointerId(event);
13270
+ const pointerState = internal.pointerMap.get(pointerId);
13271
+ if (pointerState?.captured.size) {
13272
+ requestAnimationFrame(() => {
13273
+ const pointerState2 = internal.pointerMap.get(pointerId);
13274
+ if (pointerState2?.captured.size) {
13275
+ pointerState2.captured.clear();
13276
+ }
13277
+ cancelPointer([], pointerId);
13278
+ });
13279
+ }
13280
+ };
13281
+ }
13282
+ return function handleEvent(event) {
13283
+ const state = store.getState();
13284
+ const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
13285
+ const pointerId = getPointerId(event);
13286
+ internal.lastEvent.current = event;
13287
+ if (!events.enabled) return;
13288
+ const isPointerMove = name === "onPointerMove";
13289
+ const isDragOver = name === "onDragOver";
13290
+ const isDrop = name === "onDrop";
13291
+ const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
13292
+ const isPointerDown = name === "onPointerDown";
13293
+ const isPointerUp = name === "onPointerUp";
13294
+ const isWheel = name === "onWheel";
13295
+ const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
13296
+ if (isPointerMove && canDeferRaycasts) {
13297
+ events.compute?.(event, state);
13298
+ internal.pointerDirty.set(pointerId, event);
13299
+ return;
13300
+ }
13301
+ if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
13302
+ events.compute?.(event, state);
13303
+ internal.pointerDirty.set(pointerId, event);
13304
+ return;
13305
+ }
13306
+ if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
13307
+ const deferredEvent = internal.pointerDirty.get(pointerId);
13308
+ internal.pointerDirty.delete(pointerId);
13309
+ processDeferredPointer(deferredEvent, pointerId);
13310
+ }
13311
+ const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
13312
+ const hits = intersect(event, filter);
13313
+ const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
13314
+ if (isPointerDown) {
13315
+ const pointerState2 = getPointerState(internal, pointerId);
13316
+ pointerState2.initialClick = [event.offsetX, event.offsetY];
13317
+ pointerState2.initialHits = hits.map((hit) => hit.eventObject);
13318
+ }
13319
+ const pointerState = internal.pointerMap.get(pointerId);
13320
+ const initialHits = pointerState?.initialHits ?? [];
13321
+ if (isClickEvent && !hits.length) {
13322
+ if (delta <= 2) {
13323
+ pointerMissed(event, internal.interaction);
13324
+ if (onPointerMissed) onPointerMissed(event);
13552
13325
  }
13553
- }, le.findAllNodes = kc, le.findBoundingRects = function(e, n) {
13554
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13555
- n = kc(e, n), e = [];
13556
- for (var o = 0; o < n.length; o++) e.push(ma(n[o]));
13557
- for (n = e.length - 1; 0 < n; n--) {
13558
- o = e[n];
13559
- for (var i = o.x, s = i + o.width, u = o.y, f = u + o.height, p = n - 1; 0 <= p; p--) if (n !== p) {
13560
- var g = e[p], S = g.x, T = S + g.width, _ = g.y, I = _ + g.height;
13561
- if (i >= S && u >= _ && s <= T && f <= I) {
13562
- e.splice(n, 1);
13563
- break;
13564
- } else if (i !== S || o.width !== g.width || I < u || _ > f) {
13565
- if (!(u !== _ || o.height !== g.height || T < i || S > s)) {
13566
- S > i && (g.width += S - i, g.x = i), T < s && (g.width = s - S), e.splice(n, 1);
13567
- break;
13568
- }
13569
- } else {
13570
- _ > u && (g.height += _ - u, g.y = u), I < f && (g.height = f - _), e.splice(n, 1);
13571
- break;
13326
+ }
13327
+ if (isDragOver && !hits.length) {
13328
+ dragOverMissed(event, internal.interaction);
13329
+ if (onDragOverMissed) onDragOverMissed(event);
13330
+ }
13331
+ if (isDrop && !hits.length) {
13332
+ dropMissed(event, internal.interaction);
13333
+ if (onDropMissed) onDropMissed(event);
13334
+ }
13335
+ if (isPointerMove || isDragOver) {
13336
+ cancelPointer(hits, pointerId);
13337
+ }
13338
+ function onIntersect(data) {
13339
+ const eventObject = data.eventObject;
13340
+ const instance = eventObject.__r3f;
13341
+ if (!instance?.eventCount) return;
13342
+ const handlers = instance.handlers;
13343
+ if (isPointerMove) {
13344
+ if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
13345
+ const id = makeId(data);
13346
+ const pointerState2 = getPointerState(internal, pointerId);
13347
+ const hoveredItem = pointerState2.hovered.get(id);
13348
+ if (!hoveredItem) {
13349
+ pointerState2.hovered.set(id, data);
13350
+ handlers.onPointerOver?.(data);
13351
+ handlers.onPointerEnter?.(data);
13352
+ } else if (hoveredItem.stopped) {
13353
+ data.stopPropagation();
13572
13354
  }
13573
13355
  }
13574
- }
13575
- return e;
13576
- }, le.findHostInstance = function(e) {
13577
- var n = e._reactInternals;
13578
- if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
13579
- return e = mu(n), e === null ? null : ot(e.stateNode);
13580
- }, le.findHostInstanceWithNoPortals = function(e) {
13581
- return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
13582
- }, le.findHostInstanceWithWarning = function(e, n) {
13583
- var o = e._reactInternals;
13584
- if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
13585
- if (e = mu(o), e === null) return null;
13586
- if (e.mode & 8) {
13587
- var i = G(o) || "Component";
13588
- mb[i] || (mb[i] = true, B(e, function() {
13589
- o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
13590
- }));
13591
- }
13592
- return ot(e.stateNode);
13593
- }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
13594
- var n = ye;
13595
- ye |= 1;
13596
- var o = x.T, i = wt();
13597
- try {
13598
- if (an(2), x.T = null, e) return e();
13599
- } finally {
13600
- an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
13601
- }
13602
- }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
13603
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13604
- for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
13605
- var o = n[e++], i = o.tag;
13606
- if (!Kr(o)) {
13607
- if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
13608
- for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
13356
+ handlers.onPointerMove?.(data);
13357
+ } else if (isDragOver) {
13358
+ const id = makeId(data);
13359
+ const pointerState2 = getPointerState(internal, pointerId);
13360
+ const hoveredItem = pointerState2.hovered.get(id);
13361
+ if (!hoveredItem) {
13362
+ pointerState2.hovered.set(id, data);
13363
+ handlers.onDragOverEnter?.(data);
13364
+ } else if (hoveredItem.stopped) {
13365
+ data.stopPropagation();
13366
+ }
13367
+ handlers.onDragOver?.(data);
13368
+ } else if (isDrop) {
13369
+ handlers.onDrop?.(data);
13370
+ } else {
13371
+ const handler = handlers[name];
13372
+ if (handler) {
13373
+ if (!isClickEvent || initialHits.includes(eventObject)) {
13374
+ pointerMissed(
13375
+ event,
13376
+ internal.interaction.filter((object) => !initialHits.includes(object))
13377
+ );
13378
+ handler(data);
13379
+ }
13380
+ } else {
13381
+ if (isClickEvent && initialHits.includes(eventObject)) {
13382
+ pointerMissed(
13383
+ event,
13384
+ internal.interaction.filter((object) => !initialHits.includes(object))
13385
+ );
13386
+ }
13609
13387
  }
13610
13388
  }
13611
- return false;
13612
- }, le.getFindAllNodesFailureDescription = function(e, n) {
13613
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13614
- var o = 0, i = [];
13615
- e = [Ef(e), 0];
13616
- for (var s = 0; s < e.length; ) {
13617
- var u = e[s++], f = u.tag, p = e[s++], g = n[p];
13618
- if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
13389
+ }
13390
+ handleIntersects(hits, event, delta, onIntersect);
13391
+ };
13392
+ }
13393
+ function flushDeferredPointers() {
13394
+ const { internal, events } = store.getState();
13395
+ if (!events.frameTimedRaycasts) return;
13396
+ for (const [pointerId, event] of internal.pointerDirty) {
13397
+ processDeferredPointer(event, pointerId);
13398
+ }
13399
+ internal.pointerDirty.clear();
13400
+ }
13401
+ return { handlePointer, flushDeferredPointers, processDeferredPointer };
13402
+ }
13403
+ const DOM_EVENTS = {
13404
+ onClick: ["click", false],
13405
+ onContextMenu: ["contextmenu", false],
13406
+ onDoubleClick: ["dblclick", false],
13407
+ onDragEnter: ["dragenter", false],
13408
+ onDragLeave: ["dragleave", false],
13409
+ onDragOver: ["dragover", false],
13410
+ onDrop: ["drop", false],
13411
+ onWheel: ["wheel", true],
13412
+ onPointerDown: ["pointerdown", true],
13413
+ onPointerUp: ["pointerup", true],
13414
+ onPointerLeave: ["pointerleave", true],
13415
+ onPointerMove: ["pointermove", true],
13416
+ onPointerCancel: ["pointercancel", true],
13417
+ onLostPointerCapture: ["lostpointercapture", true]
13418
+ };
13419
+ function createPointerEvents(store) {
13420
+ const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
13421
+ let nextXRPointerId = XR_POINTER_ID_START;
13422
+ const xrPointers = /* @__PURE__ */ new Map();
13423
+ return {
13424
+ priority: 1,
13425
+ enabled: true,
13426
+ frameTimedRaycasts: true,
13427
+ alwaysFireOnScroll: true,
13428
+ updateOnFrame: false,
13429
+ compute(event, state) {
13430
+ state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
13431
+ state.raycaster.setFromCamera(state.pointer, state.camera);
13432
+ },
13433
+ connected: void 0,
13434
+ handlers: Object.keys(DOM_EVENTS).reduce(
13435
+ (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
13436
+ {}
13437
+ ),
13438
+ update: (pointerId) => {
13439
+ const { events, internal } = store.getState();
13440
+ if (!events.handlers) return;
13441
+ if (pointerId !== void 0) {
13442
+ const event = internal.pointerDirty.get(pointerId);
13443
+ if (event) {
13444
+ internal.pointerDirty.delete(pointerId);
13445
+ processDeferredPointer(event, pointerId);
13446
+ } else if (internal.lastEvent?.current) {
13447
+ processDeferredPointer(internal.lastEvent.current, pointerId);
13619
13448
  }
13620
- if (o < n.length) {
13621
- for (e = []; o < n.length; o++) e.push(Sc(n[o]));
13622
- return `findAllNodes was able to match part of the selector:
13623
- ` + (i.join(" > ") + `
13624
-
13625
- No matching component was found for:
13626
- `) + e.join(" > ");
13449
+ } else {
13450
+ flushDeferredPointers();
13451
+ if (internal.lastEvent?.current) {
13452
+ events.handlers.onPointerMove(internal.lastEvent.current);
13627
13453
  }
13628
- return null;
13629
- }, le.getPublicRootInstance = function(e) {
13630
- if (e = e.current, !e.child) return null;
13631
- switch (e.child.tag) {
13632
- case 27:
13633
- case 5:
13634
- return ot(e.child.stateNode);
13635
- default:
13636
- return e.child.stateNode;
13454
+ }
13455
+ },
13456
+ flush: () => {
13457
+ const { events, internal } = store.getState();
13458
+ flushDeferredPointers();
13459
+ if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
13460
+ events.handlers.onPointerMove(internal.lastEvent.current);
13461
+ }
13462
+ },
13463
+ connect: (target) => {
13464
+ if (!target) return;
13465
+ const { set, events } = store.getState();
13466
+ events.disconnect?.();
13467
+ set((state) => ({ events: { ...state.events, connected: target } }));
13468
+ if (events.handlers) {
13469
+ for (const name in events.handlers) {
13470
+ const event = events.handlers[name];
13471
+ const [eventName, passive] = DOM_EVENTS[name];
13472
+ target.addEventListener(eventName, event, { passive });
13637
13473
  }
13638
- }, le.injectIntoDevTools = function() {
13639
- var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
13640
- return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
13641
- }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
13642
- function s() {
13643
- var S = kc(e, n);
13644
- u.forEach(function(T) {
13645
- 0 > S.indexOf(T) && g(T);
13646
- }), S.forEach(function(T) {
13647
- 0 > u.indexOf(T) && p(T);
13648
- });
13474
+ }
13475
+ },
13476
+ disconnect: () => {
13477
+ const { set, events } = store.getState();
13478
+ if (events.connected) {
13479
+ if (events.handlers) {
13480
+ for (const name in events.handlers) {
13481
+ const event = events.handlers[name];
13482
+ const [eventName] = DOM_EVENTS[name];
13483
+ events.connected.removeEventListener(eventName, event);
13484
+ }
13485
+ }
13486
+ set((state) => ({ events: { ...state.events, connected: void 0 } }));
13487
+ }
13488
+ },
13489
+ // PREVIEW (A8): the XR pointer registration API may change before stable.
13490
+ registerPointer: (config) => {
13491
+ const pointerId = nextXRPointerId++;
13492
+ xrPointers.set(pointerId, config);
13493
+ const { internal } = store.getState();
13494
+ getPointerState(internal, pointerId);
13495
+ return pointerId;
13496
+ },
13497
+ unregisterPointer: (pointerId) => {
13498
+ xrPointers.delete(pointerId);
13499
+ const { internal } = store.getState();
13500
+ const pointerState = internal.pointerMap.get(pointerId);
13501
+ if (pointerState) {
13502
+ for (const [, hoveredObj] of pointerState.hovered) {
13503
+ const eventObject = hoveredObj.eventObject;
13504
+ const instance = eventObject.__r3f;
13505
+ if (instance?.eventCount) {
13506
+ const handlers = instance.handlers;
13507
+ const data = { ...hoveredObj, intersections: [] };
13508
+ handlers.onPointerOut?.(data);
13509
+ handlers.onPointerLeave?.(data);
13510
+ }
13649
13511
  }
13650
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13651
- var u = kc(e, n);
13652
- o = zr(u, o, i);
13653
- var f = o.disconnect, p = o.observe, g = o.unobserve;
13654
- return bm.push(s), { disconnect: function() {
13655
- var S = bm.indexOf(s);
13656
- 0 <= S && bm.splice(S, 1), f();
13657
- } };
13658
- }, le.shouldError = function(e) {
13659
- return pu(e);
13660
- }, le.shouldSuspend = function(e) {
13661
- return fu(e);
13662
- }, le.startHostTransition = function(e, n, o, i) {
13663
- if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
13664
- var s = uf(e).queue;
13665
- Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
13666
- x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
13667
- var u = uf(e);
13668
- return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
13669
- });
13670
- }, le.updateContainer = function(e, n, o, i) {
13671
- var s = n.current, u = Nt(s);
13672
- return As(s, u, e, n, o, i), u;
13673
- }, le.updateContainerSync = Wh, le;
13674
- }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
13675
- })(Mg)), Mg.exports;
13676
- }
13677
- var Eb;
13678
- function n0() {
13679
- return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
13512
+ internal.pointerMap.delete(pointerId);
13513
+ }
13514
+ internal.pointerDirty.delete(pointerId);
13515
+ }
13516
+ };
13680
13517
  }
13681
- var t0 = n0();
13682
- const r0 = Xb(t0);
13683
-
13684
- const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
13685
13518
 
13686
13519
  function createReconciler(config) {
13687
13520
  const reconciler2 = r0(config);
@@ -13872,7 +13705,9 @@ function swapReconstructedInstances() {
13872
13705
  }
13873
13706
  }
13874
13707
  if (instance.isHidden) unhideInstance(instance);
13875
- if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
13708
+ if (isObject3D(instance.object) && !instance.parent) {
13709
+ removeInteractivity(findInitialRoot(instance), instance.object);
13710
+ }
13876
13711
  if (instance.object.__r3f) delete instance.object.__r3f;
13877
13712
  if (instance.type !== "primitive") disposeOnIdle(instance.object);
13878
13713
  }
@@ -13881,9 +13716,13 @@ function swapReconstructedInstances() {
13881
13716
  const parent = instance.parent;
13882
13717
  if (parent) {
13883
13718
  const target = catalogue[toPascalCase(instance.type)];
13719
+ const prevObject = instance.object;
13884
13720
  instance.object = instance.props.object ?? new target(...instance.props.args ?? []);
13885
13721
  instance.object.__r3f = instance;
13886
13722
  setFiberRef(fiber, instance.object);
13723
+ if (isObject3D(prevObject) && isObject3D(instance.object)) {
13724
+ swapInteractivity(findInitialRoot(instance), prevObject, instance.object);
13725
+ }
13887
13726
  delete instance.appliedOnce;
13888
13727
  instance.eventCount = 0;
13889
13728
  instance.handlers = {};
@@ -14814,6 +14653,212 @@ function flushSync(fn) {
14814
14653
  return reconciler.flushSyncFromReconciler(fn);
14815
14654
  }
14816
14655
 
14656
+ const isRef = (obj) => obj.current && obj.current.isScene;
14657
+ const resolveScene = (scene) => isRef(scene) ? scene.current : scene;
14658
+ function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
14659
+ sceneProps = {
14660
+ backgroundBlurriness: 0,
14661
+ backgroundIntensity: 1,
14662
+ backgroundRotation: [0, 0, 0],
14663
+ environmentIntensity: 1,
14664
+ environmentRotation: [0, 0, 0],
14665
+ ...sceneProps
14666
+ };
14667
+ const target = resolveScene(scene || defaultScene);
14668
+ const oldbg = target.background;
14669
+ const oldenv = target.environment;
14670
+ const oldSceneProps = {
14671
+ // @ts-ignore
14672
+ backgroundBlurriness: target.backgroundBlurriness,
14673
+ // @ts-ignore
14674
+ backgroundIntensity: target.backgroundIntensity,
14675
+ // @ts-ignore
14676
+ backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
14677
+ // @ts-ignore
14678
+ environmentIntensity: target.environmentIntensity,
14679
+ // @ts-ignore
14680
+ environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
14681
+ };
14682
+ if (background !== "only") target.environment = texture;
14683
+ if (background) target.background = texture;
14684
+ applyProps(target, sceneProps);
14685
+ return () => {
14686
+ if (background !== "only") target.environment = oldenv;
14687
+ if (background) target.background = oldbg;
14688
+ applyProps(target, oldSceneProps);
14689
+ };
14690
+ }
14691
+ function EnvironmentMap({ scene, background = false, map, ...config }) {
14692
+ const defaultScene = useThree((state) => state.scene);
14693
+ React.useLayoutEffect(() => {
14694
+ if (map) return setEnvProps(background, scene, defaultScene, map, config);
14695
+ });
14696
+ return null;
14697
+ }
14698
+ function EnvironmentCube({
14699
+ background = false,
14700
+ scene,
14701
+ blur,
14702
+ backgroundBlurriness,
14703
+ backgroundIntensity,
14704
+ backgroundRotation,
14705
+ environmentIntensity,
14706
+ environmentRotation,
14707
+ ...rest
14708
+ }) {
14709
+ const texture = useEnvironment(rest);
14710
+ const defaultScene = useThree((state) => state.scene);
14711
+ React.useLayoutEffect(() => {
14712
+ return setEnvProps(background, scene, defaultScene, texture, {
14713
+ backgroundBlurriness: blur ?? backgroundBlurriness,
14714
+ backgroundIntensity,
14715
+ backgroundRotation,
14716
+ environmentIntensity,
14717
+ environmentRotation
14718
+ });
14719
+ });
14720
+ React.useEffect(() => {
14721
+ return () => {
14722
+ texture.dispose();
14723
+ };
14724
+ }, [texture]);
14725
+ return null;
14726
+ }
14727
+ function EnvironmentPortal({
14728
+ children,
14729
+ near = 0.1,
14730
+ far = 1e3,
14731
+ resolution = 256,
14732
+ frames = 1,
14733
+ map,
14734
+ background = false,
14735
+ blur,
14736
+ backgroundBlurriness,
14737
+ backgroundIntensity,
14738
+ backgroundRotation,
14739
+ environmentIntensity,
14740
+ environmentRotation,
14741
+ scene,
14742
+ files,
14743
+ path,
14744
+ preset = void 0,
14745
+ extensions
14746
+ }) {
14747
+ const renderer = useThree((state) => state.renderer);
14748
+ const isLegacy = useThree((state) => state.isLegacy);
14749
+ const defaultScene = useThree((state) => state.scene);
14750
+ const camera = React.useRef(null);
14751
+ const [virtualScene] = React.useState(() => new Scene());
14752
+ const fbo = React.useMemo(() => {
14753
+ const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
14754
+ fbo2.texture.type = HalfFloatType;
14755
+ return fbo2;
14756
+ }, [resolution, isLegacy]);
14757
+ React.useEffect(() => {
14758
+ return () => {
14759
+ fbo.dispose();
14760
+ };
14761
+ }, [fbo]);
14762
+ React.useLayoutEffect(() => {
14763
+ if (frames === 1) {
14764
+ const autoClear = renderer.autoClear;
14765
+ renderer.autoClear = true;
14766
+ camera.current.update(renderer, virtualScene);
14767
+ renderer.autoClear = autoClear;
14768
+ }
14769
+ return setEnvProps(background, scene, defaultScene, fbo.texture, {
14770
+ backgroundBlurriness: blur ?? backgroundBlurriness,
14771
+ backgroundIntensity,
14772
+ backgroundRotation,
14773
+ environmentIntensity,
14774
+ environmentRotation
14775
+ });
14776
+ }, [
14777
+ children,
14778
+ virtualScene,
14779
+ fbo.texture,
14780
+ scene,
14781
+ defaultScene,
14782
+ background,
14783
+ frames,
14784
+ renderer,
14785
+ blur,
14786
+ backgroundBlurriness,
14787
+ backgroundIntensity,
14788
+ backgroundRotation,
14789
+ environmentIntensity,
14790
+ environmentRotation
14791
+ ]);
14792
+ let count = 1;
14793
+ useFrame(() => {
14794
+ if (frames === Infinity || count < frames) {
14795
+ const autoClear = renderer.autoClear;
14796
+ renderer.autoClear = true;
14797
+ camera.current.update(renderer, virtualScene);
14798
+ renderer.autoClear = autoClear;
14799
+ count++;
14800
+ }
14801
+ });
14802
+ return /* @__PURE__ */ jsx(Fragment, { children: createPortal(
14803
+ /* @__PURE__ */ jsxs(Fragment, { children: [
14804
+ children,
14805
+ /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
14806
+ files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
14807
+ ] }),
14808
+ virtualScene
14809
+ ) });
14810
+ }
14811
+ function EnvironmentGround(props) {
14812
+ const textureDefault = useEnvironment(props);
14813
+ const texture = props.map || textureDefault;
14814
+ React.useMemo(() => extend({ GroundProjectedEnvImpl: GroundedSkybox }), []);
14815
+ React.useEffect(() => {
14816
+ return () => {
14817
+ textureDefault.dispose();
14818
+ };
14819
+ }, [textureDefault]);
14820
+ const height = props.ground?.height ?? 15;
14821
+ const radius = props.ground?.radius ?? 60;
14822
+ const scale = props.ground?.scale ?? 1e3;
14823
+ const args = React.useMemo(
14824
+ () => [texture, height, radius],
14825
+ [texture, height, radius]
14826
+ );
14827
+ return /* @__PURE__ */ jsxs(Fragment, { children: [
14828
+ /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
14829
+ /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
14830
+ ] });
14831
+ }
14832
+ function EnvironmentColor({ color, scene }) {
14833
+ const defaultScene = useThree((state) => state.scene);
14834
+ React.useLayoutEffect(() => {
14835
+ if (color === void 0) return;
14836
+ const target = resolveScene(scene || defaultScene);
14837
+ const oldBg = target.background;
14838
+ target.background = new Color(color);
14839
+ return () => {
14840
+ target.background = oldBg;
14841
+ };
14842
+ });
14843
+ return null;
14844
+ }
14845
+ function EnvironmentDualSource(props) {
14846
+ const { backgroundFiles, ...envProps } = props;
14847
+ return /* @__PURE__ */ jsxs(Fragment, { children: [
14848
+ /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
14849
+ /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
14850
+ ] });
14851
+ }
14852
+ function Environment(props) {
14853
+ if (props.color && !props.files && !props.preset && !props.map) {
14854
+ return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
14855
+ }
14856
+ if (props.backgroundFiles && props.backgroundFiles !== props.files) {
14857
+ return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
14858
+ }
14859
+ return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
14860
+ }
14861
+
14817
14862
  function parseBackground(background) {
14818
14863
  if (!background) return null;
14819
14864
  if (typeof background === "object" && !background.isColor) {
@@ -15023,7 +15068,7 @@ function CanvasImpl({
15023
15068
  onDropMissed: (...args) => handleDropMissed.current?.(...args),
15024
15069
  onCreated: (state) => {
15025
15070
  state.events.connect?.(
15026
- eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current
15071
+ eventSource ? isRef$1(eventSource) ? eventSource.current : eventSource : divRef.current
15027
15072
  );
15028
15073
  if (eventPrefix) {
15029
15074
  state.setEvents({
@@ -15136,4 +15181,4 @@ function Canvas(props) {
15136
15181
 
15137
15182
  extend(THREE);
15138
15183
 
15139
- export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
15184
+ export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef$1 as isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };