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