@react-three/fiber 10.0.0-canary.5c62eb9 → 10.0.0-canary.6d6e5ab
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 +323 -135
- package/dist/index.d.cts +50 -31
- package/dist/index.d.mts +50 -31
- package/dist/index.d.ts +50 -31
- package/dist/index.mjs +327 -138
- package/dist/legacy.cjs +278 -90
- package/dist/legacy.d.cts +50 -30
- package/dist/legacy.d.mts +50 -30
- package/dist/legacy.d.ts +50 -30
- package/dist/legacy.mjs +281 -92
- package/dist/webgpu/index.cjs +610 -663
- package/dist/webgpu/index.d.cts +84 -35
- package/dist/webgpu/index.d.mts +84 -35
- package/dist/webgpu/index.d.ts +84 -35
- package/dist/webgpu/index.mjs +614 -666
- package/package.json +3 -3
- package/readme.md +0 -1
package/dist/index.mjs
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import * as webgpu from 'three/webgpu';
|
|
2
|
-
import { RenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene,
|
|
3
|
-
import { WebGLRenderTarget, WebGLRenderer } from 'three';
|
|
2
|
+
import { CubeRenderTarget, RenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene, HalfFloatType, Color, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer } from 'three/webgpu';
|
|
3
|
+
import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer } from 'three';
|
|
4
4
|
import { Inspector } from 'three/addons/inspector/Inspector.js';
|
|
5
5
|
import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
|
|
6
6
|
import * as React from 'react';
|
|
@@ -13,7 +13,7 @@ import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
|
|
|
13
13
|
import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
|
|
14
14
|
import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
|
|
15
15
|
import { GainMapLoader } from '@monogrid/gainmap-js';
|
|
16
|
-
import Tb, {
|
|
16
|
+
import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
|
|
17
17
|
import { createWithEqualityFn } from 'zustand/traditional';
|
|
18
18
|
import { getScheduler } from '@pmndrs/scheduler';
|
|
19
19
|
export { Scheduler, getScheduler } from '@pmndrs/scheduler';
|
|
@@ -36,10 +36,13 @@ const R3F_BUILD_WEBGPU = true;
|
|
|
36
36
|
|
|
37
37
|
const THREE = /*#__PURE__*/_mergeNamespaces({
|
|
38
38
|
__proto__: null,
|
|
39
|
+
CubeRenderTarget: CubeRenderTarget,
|
|
40
|
+
CubeRenderTargetCompat: CubeRenderTarget,
|
|
39
41
|
Inspector: Inspector,
|
|
40
42
|
R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
|
|
41
43
|
R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
|
|
42
44
|
RenderTargetCompat: RenderTarget,
|
|
45
|
+
WebGLCubeRenderTarget: WebGLCubeRenderTarget,
|
|
43
46
|
WebGLRenderTarget: WebGLRenderTarget,
|
|
44
47
|
WebGLRenderer: WebGLRenderer
|
|
45
48
|
}, [webgpu]);
|
|
@@ -313,15 +316,16 @@ function EnvironmentPortal({
|
|
|
313
316
|
preset = void 0,
|
|
314
317
|
extensions
|
|
315
318
|
}) {
|
|
316
|
-
const
|
|
319
|
+
const renderer = useThree$1((state) => state.renderer);
|
|
320
|
+
const isLegacy = useThree$1((state) => state.isLegacy);
|
|
317
321
|
const defaultScene = useThree$1((state) => state.scene);
|
|
318
322
|
const camera = React.useRef(null);
|
|
319
323
|
const [virtualScene] = React.useState(() => new Scene());
|
|
320
324
|
const fbo = React.useMemo(() => {
|
|
321
|
-
const fbo2 = new WebGLCubeRenderTarget(resolution);
|
|
325
|
+
const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
|
|
322
326
|
fbo2.texture.type = HalfFloatType;
|
|
323
327
|
return fbo2;
|
|
324
|
-
}, [resolution]);
|
|
328
|
+
}, [resolution, isLegacy]);
|
|
325
329
|
React.useEffect(() => {
|
|
326
330
|
return () => {
|
|
327
331
|
fbo.dispose();
|
|
@@ -329,10 +333,10 @@ function EnvironmentPortal({
|
|
|
329
333
|
}, [fbo]);
|
|
330
334
|
React.useLayoutEffect(() => {
|
|
331
335
|
if (frames === 1) {
|
|
332
|
-
const autoClear =
|
|
333
|
-
|
|
334
|
-
camera.current.update(
|
|
335
|
-
|
|
336
|
+
const autoClear = renderer.autoClear;
|
|
337
|
+
renderer.autoClear = true;
|
|
338
|
+
camera.current.update(renderer, virtualScene);
|
|
339
|
+
renderer.autoClear = autoClear;
|
|
336
340
|
}
|
|
337
341
|
return setEnvProps(background, scene, defaultScene, fbo.texture, {
|
|
338
342
|
backgroundBlurriness: blur ?? backgroundBlurriness,
|
|
@@ -349,7 +353,7 @@ function EnvironmentPortal({
|
|
|
349
353
|
defaultScene,
|
|
350
354
|
background,
|
|
351
355
|
frames,
|
|
352
|
-
|
|
356
|
+
renderer,
|
|
353
357
|
blur,
|
|
354
358
|
backgroundBlurriness,
|
|
355
359
|
backgroundIntensity,
|
|
@@ -360,10 +364,10 @@ function EnvironmentPortal({
|
|
|
360
364
|
let count = 1;
|
|
361
365
|
useFrame$1(() => {
|
|
362
366
|
if (frames === Infinity || count < frames) {
|
|
363
|
-
const autoClear =
|
|
364
|
-
|
|
365
|
-
camera.current.update(
|
|
366
|
-
|
|
367
|
+
const autoClear = renderer.autoClear;
|
|
368
|
+
renderer.autoClear = true;
|
|
369
|
+
camera.current.update(renderer, virtualScene);
|
|
370
|
+
renderer.autoClear = autoClear;
|
|
367
371
|
count++;
|
|
368
372
|
}
|
|
369
373
|
});
|
|
@@ -430,7 +434,6 @@ function Environment(props) {
|
|
|
430
434
|
var __defProp = Object.defineProperty;
|
|
431
435
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
432
436
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
433
|
-
const act = React["act"];
|
|
434
437
|
const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
|
|
435
438
|
function useMutableCallback(fn) {
|
|
436
439
|
const ref = React.useRef(fn);
|
|
@@ -606,8 +609,7 @@ function prepare(target, root, type, props) {
|
|
|
606
609
|
object,
|
|
607
610
|
eventCount: 0,
|
|
608
611
|
handlers: {},
|
|
609
|
-
isHidden: false
|
|
610
|
-
deferredRefs: []
|
|
612
|
+
isHidden: false
|
|
611
613
|
};
|
|
612
614
|
if (object) object.__r3f = instance;
|
|
613
615
|
}
|
|
@@ -764,6 +766,17 @@ function unregisterVisibility(store, object) {
|
|
|
764
766
|
internal.visibilityRegistry.delete(object.uuid);
|
|
765
767
|
internal.occlusionCache.delete(object);
|
|
766
768
|
}
|
|
769
|
+
function updateVisibilityHandlers(store, object, handlers) {
|
|
770
|
+
const { internal } = store.getState();
|
|
771
|
+
const entry = internal.visibilityRegistry.get(object.uuid);
|
|
772
|
+
if (!entry) return false;
|
|
773
|
+
entry.handlers = handlers;
|
|
774
|
+
if ((handlers.onOccluded || handlers.onVisible) && !internal.occlusionEnabled) {
|
|
775
|
+
object.occlusionTest = true;
|
|
776
|
+
enableOcclusion(store);
|
|
777
|
+
}
|
|
778
|
+
return true;
|
|
779
|
+
}
|
|
767
780
|
function checkVisibility(state) {
|
|
768
781
|
const { internal, camera } = state;
|
|
769
782
|
const registry = internal.visibilityRegistry;
|
|
@@ -924,9 +937,9 @@ function diffProps(instance, newProps) {
|
|
|
924
937
|
const { root, key } = resolve(instance.object, prop);
|
|
925
938
|
if (root.constructor && root.constructor.length === 0) {
|
|
926
939
|
const ctor = getMemoizedPrototype(root);
|
|
927
|
-
if (!is.und(ctor)) changedProps[
|
|
940
|
+
if (!is.und(ctor)) changedProps[prop] = ctor[key];
|
|
928
941
|
} else {
|
|
929
|
-
changedProps[
|
|
942
|
+
changedProps[prop] = 0;
|
|
930
943
|
}
|
|
931
944
|
}
|
|
932
945
|
return changedProps;
|
|
@@ -951,10 +964,7 @@ function applyProps(object, props) {
|
|
|
951
964
|
continue;
|
|
952
965
|
}
|
|
953
966
|
if (value === void 0) continue;
|
|
954
|
-
if (isFromRef(value))
|
|
955
|
-
instance?.deferredRefs?.push({ prop, ref: value[FROM_REF] });
|
|
956
|
-
continue;
|
|
957
|
-
}
|
|
967
|
+
if (isFromRef(value)) continue;
|
|
958
968
|
if (isOnce(value)) {
|
|
959
969
|
if (instance?.appliedOnce?.has(prop)) continue;
|
|
960
970
|
if (instance) {
|
|
@@ -990,6 +1000,19 @@ function applyProps(object, props) {
|
|
|
990
1000
|
} else if (isVectorLike(target) && is.num(value)) {
|
|
991
1001
|
if ("setScalar" in target && typeof target.setScalar === "function") target.setScalar(value);
|
|
992
1002
|
else target.set(value);
|
|
1003
|
+
} else if (root instanceof ShaderMaterial && key === "uniforms" && is.obj(value)) {
|
|
1004
|
+
if (!is.obj(root.uniforms)) root.uniforms = {};
|
|
1005
|
+
const uniforms = root.uniforms;
|
|
1006
|
+
const nextUniforms = value;
|
|
1007
|
+
for (const name in nextUniforms) {
|
|
1008
|
+
const uniform = nextUniforms[name];
|
|
1009
|
+
const targetUniform = uniforms[name];
|
|
1010
|
+
if (targetUniform) Object.assign(targetUniform, uniform);
|
|
1011
|
+
else {
|
|
1012
|
+
const nextUniform = uniform instanceof Uniform ? uniform.clone() : new Uniform(uniform.value);
|
|
1013
|
+
uniforms[name] = nextUniform;
|
|
1014
|
+
}
|
|
1015
|
+
}
|
|
993
1016
|
} else {
|
|
994
1017
|
root[key] = value;
|
|
995
1018
|
if (key.endsWith("Node") && root.isMaterial) {
|
|
@@ -1008,6 +1031,9 @@ function applyProps(object, props) {
|
|
|
1008
1031
|
if (instance.eventCount && object2.raycast !== null) {
|
|
1009
1032
|
rootState.internal.interaction.push(object2);
|
|
1010
1033
|
}
|
|
1034
|
+
}
|
|
1035
|
+
if (instance?.parent && rootState?.internal && instance.object?.isObject3D) {
|
|
1036
|
+
const object2 = instance.object;
|
|
1011
1037
|
const root = findInitialRoot(instance);
|
|
1012
1038
|
const visibilityHandlers = {
|
|
1013
1039
|
onFramed: instance.handlers.onFramed,
|
|
@@ -1015,7 +1041,9 @@ function applyProps(object, props) {
|
|
|
1015
1041
|
onVisible: instance.handlers.onVisible
|
|
1016
1042
|
};
|
|
1017
1043
|
if (hasVisibilityHandlers(visibilityHandlers)) {
|
|
1018
|
-
|
|
1044
|
+
if (!updateVisibilityHandlers(root, object2, visibilityHandlers)) {
|
|
1045
|
+
registerVisibility(root, object2, visibilityHandlers);
|
|
1046
|
+
}
|
|
1019
1047
|
} else {
|
|
1020
1048
|
unregisterVisibility(root, object2);
|
|
1021
1049
|
}
|
|
@@ -1543,6 +1571,7 @@ function createPointerEvents(store) {
|
|
|
1543
1571
|
set((state) => ({ events: { ...state.events, connected: void 0 } }));
|
|
1544
1572
|
}
|
|
1545
1573
|
},
|
|
1574
|
+
// PREVIEW (A8): the XR pointer registration API may change before stable.
|
|
1546
1575
|
registerPointer: (config) => {
|
|
1547
1576
|
const pointerId = nextXRPointerId++;
|
|
1548
1577
|
xrPointers.set(pointerId, config);
|
|
@@ -1630,11 +1659,10 @@ function notifyAlpha({ message, link }) {
|
|
|
1630
1659
|
}
|
|
1631
1660
|
|
|
1632
1661
|
const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
|
|
1633
|
-
const INTERNAL_FIBER_MARKERS = ["packages/fiber/src", "packages/fiber/dist", "@react-three/fiber", "@react-three_fiber"];
|
|
1634
1662
|
function isInternalRendererAccess(stack, callerDepth = 2) {
|
|
1635
1663
|
if (!stack) return false;
|
|
1636
1664
|
const caller = stack.split("\n")[callerDepth] ?? "";
|
|
1637
|
-
return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m))
|
|
1665
|
+
return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
|
|
1638
1666
|
}
|
|
1639
1667
|
|
|
1640
1668
|
const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
|
|
@@ -1769,6 +1797,7 @@ const createStore = (invalidate, advance) => {
|
|
|
1769
1797
|
}),
|
|
1770
1798
|
setFrameloop: (frameloop = "always") => {
|
|
1771
1799
|
set(() => ({ frameloop }));
|
|
1800
|
+
getScheduler().frameloop = frameloop;
|
|
1772
1801
|
},
|
|
1773
1802
|
setError: (error) => set(() => ({ error })),
|
|
1774
1803
|
error: null,
|
|
@@ -1949,19 +1978,25 @@ function loadingFn(extensions, onProgress) {
|
|
|
1949
1978
|
);
|
|
1950
1979
|
};
|
|
1951
1980
|
}
|
|
1952
|
-
function useLoader(loader, input, extensions, onProgress) {
|
|
1953
|
-
const
|
|
1981
|
+
function useLoader(loader, input, extensions, onProgress, cacheKey) {
|
|
1982
|
+
const inputs = Array.isArray(input) ? input : [input];
|
|
1983
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
1954
1984
|
const fn = loadingFn(extensions, onProgress);
|
|
1955
|
-
const results =
|
|
1985
|
+
const results = cacheKeys.map(
|
|
1986
|
+
(key, index) => suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
|
|
1987
|
+
);
|
|
1956
1988
|
return Array.isArray(input) ? results : results[0];
|
|
1957
1989
|
}
|
|
1958
|
-
useLoader.preload = function(loader, input, extensions, onProgress) {
|
|
1959
|
-
const
|
|
1960
|
-
|
|
1990
|
+
useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
|
|
1991
|
+
const inputs = Array.isArray(input) ? input : [input];
|
|
1992
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
1993
|
+
cacheKeys.forEach(
|
|
1994
|
+
(key, index) => preload(() => loadingFn(extensions, onProgress)(loader, inputs[index]), [loader, key])
|
|
1995
|
+
);
|
|
1961
1996
|
};
|
|
1962
|
-
useLoader.clear = function(loader, input) {
|
|
1963
|
-
const
|
|
1964
|
-
|
|
1997
|
+
useLoader.clear = function(loader, input, cacheKey) {
|
|
1998
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
1999
|
+
cacheKeys.forEach((key) => clear([loader, key]));
|
|
1965
2000
|
};
|
|
1966
2001
|
useLoader.loader = getLoader;
|
|
1967
2002
|
|
|
@@ -2383,7 +2418,7 @@ function advance(timestamp) {
|
|
|
2383
2418
|
getScheduler().step(timestamp);
|
|
2384
2419
|
}
|
|
2385
2420
|
|
|
2386
|
-
const version = "10.0.0-alpha.
|
|
2421
|
+
const version = "10.0.0-alpha.3";
|
|
2387
2422
|
const packageData = {
|
|
2388
2423
|
version: version};
|
|
2389
2424
|
|
|
@@ -13639,7 +13674,7 @@ function n0() {
|
|
|
13639
13674
|
var t0 = n0();
|
|
13640
13675
|
const r0 = Xb(t0);
|
|
13641
13676
|
|
|
13642
|
-
const t = 1, o = 8, r = 32, e = 2;
|
|
13677
|
+
const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
|
|
13643
13678
|
|
|
13644
13679
|
function createReconciler(config) {
|
|
13645
13680
|
const reconciler2 = r0(config);
|
|
@@ -13804,7 +13839,15 @@ function setFiberRef(fiber, publicInstance) {
|
|
|
13804
13839
|
}
|
|
13805
13840
|
}
|
|
13806
13841
|
const reconstructed = [];
|
|
13807
|
-
function
|
|
13842
|
+
function flushReconstructedInstances() {
|
|
13843
|
+
if (reconstructed.length === 0) return;
|
|
13844
|
+
try {
|
|
13845
|
+
swapReconstructedInstances();
|
|
13846
|
+
} finally {
|
|
13847
|
+
reconstructed.length = 0;
|
|
13848
|
+
}
|
|
13849
|
+
}
|
|
13850
|
+
function swapReconstructedInstances() {
|
|
13808
13851
|
for (const [instance] of reconstructed) {
|
|
13809
13852
|
const parent = instance.parent;
|
|
13810
13853
|
if (parent) {
|
|
@@ -13822,6 +13865,7 @@ function swapInstances() {
|
|
|
13822
13865
|
}
|
|
13823
13866
|
}
|
|
13824
13867
|
if (instance.isHidden) unhideInstance(instance);
|
|
13868
|
+
if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
|
|
13825
13869
|
if (instance.object.__r3f) delete instance.object.__r3f;
|
|
13826
13870
|
if (instance.type !== "primitive") disposeOnIdle(instance.object);
|
|
13827
13871
|
}
|
|
@@ -13834,6 +13878,8 @@ function swapInstances() {
|
|
|
13834
13878
|
instance.object.__r3f = instance;
|
|
13835
13879
|
setFiberRef(fiber, instance.object);
|
|
13836
13880
|
delete instance.appliedOnce;
|
|
13881
|
+
instance.eventCount = 0;
|
|
13882
|
+
instance.handlers = {};
|
|
13837
13883
|
applyProps(instance.object, instance.props);
|
|
13838
13884
|
if (instance.props.attach) {
|
|
13839
13885
|
attach(parent, instance);
|
|
@@ -13850,14 +13896,114 @@ function swapInstances() {
|
|
|
13850
13896
|
invalidateInstance(instance);
|
|
13851
13897
|
}
|
|
13852
13898
|
}
|
|
13853
|
-
reconstructed.length = 0;
|
|
13854
13899
|
}
|
|
13855
13900
|
const handleTextInstance = () => {
|
|
13856
13901
|
};
|
|
13857
13902
|
const NO_CONTEXT = {};
|
|
13858
13903
|
let currentUpdatePriority = NoEventPriority;
|
|
13859
|
-
|
|
13860
|
-
|
|
13904
|
+
function getEventPriority(type) {
|
|
13905
|
+
switch (type) {
|
|
13906
|
+
case "beforetoggle":
|
|
13907
|
+
case "cancel":
|
|
13908
|
+
case "click":
|
|
13909
|
+
case "close":
|
|
13910
|
+
case "contextmenu":
|
|
13911
|
+
case "copy":
|
|
13912
|
+
case "cut":
|
|
13913
|
+
case "auxclick":
|
|
13914
|
+
case "dblclick":
|
|
13915
|
+
case "dragend":
|
|
13916
|
+
case "dragstart":
|
|
13917
|
+
case "drop":
|
|
13918
|
+
case "focusin":
|
|
13919
|
+
case "focusout":
|
|
13920
|
+
case "input":
|
|
13921
|
+
case "invalid":
|
|
13922
|
+
case "keydown":
|
|
13923
|
+
case "keypress":
|
|
13924
|
+
case "keyup":
|
|
13925
|
+
case "mousedown":
|
|
13926
|
+
case "mouseup":
|
|
13927
|
+
case "paste":
|
|
13928
|
+
case "pause":
|
|
13929
|
+
case "play":
|
|
13930
|
+
case "pointercancel":
|
|
13931
|
+
case "pointerdown":
|
|
13932
|
+
case "pointerup":
|
|
13933
|
+
case "ratechange":
|
|
13934
|
+
case "reset":
|
|
13935
|
+
case "resize":
|
|
13936
|
+
case "seeked":
|
|
13937
|
+
case "submit":
|
|
13938
|
+
case "touchcancel":
|
|
13939
|
+
case "touchend":
|
|
13940
|
+
case "touchstart":
|
|
13941
|
+
case "volumechange":
|
|
13942
|
+
case "change":
|
|
13943
|
+
case "selectionchange":
|
|
13944
|
+
case "compositionstart":
|
|
13945
|
+
case "compositionend":
|
|
13946
|
+
case "compositionupdate":
|
|
13947
|
+
case "beforeinput":
|
|
13948
|
+
case "blur":
|
|
13949
|
+
case "fullscreenchange":
|
|
13950
|
+
case "focus":
|
|
13951
|
+
case "hashchange":
|
|
13952
|
+
case "popstate":
|
|
13953
|
+
case "select":
|
|
13954
|
+
case "selectstart":
|
|
13955
|
+
return e;
|
|
13956
|
+
case "drag":
|
|
13957
|
+
case "dragenter":
|
|
13958
|
+
case "dragexit":
|
|
13959
|
+
case "dragleave":
|
|
13960
|
+
case "dragover":
|
|
13961
|
+
case "mousemove":
|
|
13962
|
+
case "mouseout":
|
|
13963
|
+
case "mouseover":
|
|
13964
|
+
case "pointermove":
|
|
13965
|
+
case "pointerout":
|
|
13966
|
+
case "pointerover":
|
|
13967
|
+
case "scroll":
|
|
13968
|
+
case "touchmove":
|
|
13969
|
+
case "wheel":
|
|
13970
|
+
case "mouseenter":
|
|
13971
|
+
case "mouseleave":
|
|
13972
|
+
case "pointerenter":
|
|
13973
|
+
case "pointerleave":
|
|
13974
|
+
return o;
|
|
13975
|
+
case "message": {
|
|
13976
|
+
switch (unstable_getCurrentPriorityLevel()) {
|
|
13977
|
+
case unstable_ImmediatePriority:
|
|
13978
|
+
return e;
|
|
13979
|
+
case unstable_UserBlockingPriority:
|
|
13980
|
+
return o;
|
|
13981
|
+
case unstable_NormalPriority:
|
|
13982
|
+
case unstable_LowPriority:
|
|
13983
|
+
return r;
|
|
13984
|
+
case unstable_IdlePriority:
|
|
13985
|
+
return i$1;
|
|
13986
|
+
default:
|
|
13987
|
+
return r;
|
|
13988
|
+
}
|
|
13989
|
+
}
|
|
13990
|
+
default:
|
|
13991
|
+
return r;
|
|
13992
|
+
}
|
|
13993
|
+
}
|
|
13994
|
+
function scheduleMicrotask(callback) {
|
|
13995
|
+
if (typeof queueMicrotask === "function") {
|
|
13996
|
+
queueMicrotask(callback);
|
|
13997
|
+
} else if (typeof Promise !== "undefined") {
|
|
13998
|
+
Promise.resolve().then(callback).catch((error) => {
|
|
13999
|
+
setTimeout(() => {
|
|
14000
|
+
throw error;
|
|
14001
|
+
});
|
|
14002
|
+
});
|
|
14003
|
+
} else {
|
|
14004
|
+
setTimeout(callback);
|
|
14005
|
+
}
|
|
14006
|
+
}
|
|
13861
14007
|
const reconciler = /* @__PURE__ */ createReconciler({
|
|
13862
14008
|
isPrimaryRenderer: false,
|
|
13863
14009
|
warnsIfNotActing: false,
|
|
@@ -13896,16 +14042,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13896
14042
|
else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
|
|
13897
14043
|
else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
|
|
13898
14044
|
if (reconstruct) {
|
|
13899
|
-
reconstructed.push([instance,
|
|
14045
|
+
reconstructed.push([instance, getInstanceProps(newProps), fiber]);
|
|
13900
14046
|
} else {
|
|
13901
14047
|
const changedProps = diffProps(instance, newProps);
|
|
13902
|
-
|
|
13903
|
-
|
|
13904
|
-
|
|
13905
|
-
|
|
14048
|
+
const attach2 = instance.props.attach;
|
|
14049
|
+
instance.props = getInstanceProps(newProps);
|
|
14050
|
+
if (attach2 !== void 0) instance.props.attach = attach2;
|
|
14051
|
+
else delete instance.props.attach;
|
|
14052
|
+
if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
|
|
13906
14053
|
}
|
|
13907
|
-
const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
|
|
13908
|
-
if (isTailSibling) swapInstances();
|
|
13909
14054
|
},
|
|
13910
14055
|
finalizeInitialChildren: (instance) => {
|
|
13911
14056
|
for (const prop in instance.props) {
|
|
@@ -13930,8 +14075,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13930
14075
|
const target = container.getState().internal.container ?? container.getState().scene;
|
|
13931
14076
|
return prepare(target, container, "", {});
|
|
13932
14077
|
},
|
|
13933
|
-
|
|
13934
|
-
|
|
14078
|
+
// Reconstructed instances are swapped once all mutations are committed,
|
|
14079
|
+
// before layout effects run so refs point to the new objects
|
|
14080
|
+
resetAfterCommit: flushReconstructedInstances,
|
|
13935
14081
|
shouldSetTextContent: () => false,
|
|
13936
14082
|
clearContainer: () => false,
|
|
13937
14083
|
hideInstance,
|
|
@@ -13939,6 +14085,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13939
14085
|
createTextInstance: handleTextInstance,
|
|
13940
14086
|
hideTextInstance: handleTextInstance,
|
|
13941
14087
|
unhideTextInstance: handleTextInstance,
|
|
14088
|
+
// Mirrors react-dom, which flushes discrete work in microtasks
|
|
14089
|
+
supportsMicrotasks: true,
|
|
14090
|
+
scheduleMicrotask,
|
|
13942
14091
|
scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
|
|
13943
14092
|
cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
|
|
13944
14093
|
noTimeout: -1,
|
|
@@ -13979,28 +14128,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13979
14128
|
},
|
|
13980
14129
|
resolveUpdatePriority() {
|
|
13981
14130
|
if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
|
|
13982
|
-
|
|
13983
|
-
|
|
13984
|
-
|
|
13985
|
-
case "dblclick":
|
|
13986
|
-
case "dragenter":
|
|
13987
|
-
case "dragleave":
|
|
13988
|
-
case "drop":
|
|
13989
|
-
case "pointercancel":
|
|
13990
|
-
case "pointerdown":
|
|
13991
|
-
case "pointerup":
|
|
13992
|
-
return e;
|
|
13993
|
-
case "dragover":
|
|
13994
|
-
case "pointermove":
|
|
13995
|
-
case "pointerout":
|
|
13996
|
-
case "pointerover":
|
|
13997
|
-
case "pointerenter":
|
|
13998
|
-
case "pointerleave":
|
|
13999
|
-
case "wheel":
|
|
14000
|
-
return o;
|
|
14001
|
-
default:
|
|
14002
|
-
return r;
|
|
14003
|
-
}
|
|
14131
|
+
const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
|
|
14132
|
+
if (eventType === void 0) return r;
|
|
14133
|
+
return getEventPriority(eventType);
|
|
14004
14134
|
},
|
|
14005
14135
|
resetFormInstance() {
|
|
14006
14136
|
},
|
|
@@ -14049,11 +14179,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
14049
14179
|
cloneMutableTextInstance(textInstance) {
|
|
14050
14180
|
return textInstance;
|
|
14051
14181
|
},
|
|
14182
|
+
// React 19.2 added these for root-level view transitions. They only run for hosts that opt into
|
|
14183
|
+
// view transitions by returning a container from cloneRootViewTransitionContainer; R3F renders
|
|
14184
|
+
// into a WebGL/WebGPU canvas, where cloning the root has no meaning, so we never opt in and
|
|
14185
|
+
// React never calls them. They stay as no-ops rather than throws: the host config is shared by
|
|
14186
|
+
// every root, and a throw here would turn a React-internal probe into a hard crash for users.
|
|
14187
|
+
// Guarded by a test asserting a full render + unmount never reaches them.
|
|
14052
14188
|
cloneRootViewTransitionContainer(_rootContainer) {
|
|
14053
|
-
throw new Error("Not implemented.");
|
|
14054
14189
|
},
|
|
14055
14190
|
removeRootViewTransitionClone(_rootContainer, _clone) {
|
|
14056
|
-
throw new Error("Not implemented.");
|
|
14057
14191
|
},
|
|
14058
14192
|
// https://github.com/facebook/react/pull/32465
|
|
14059
14193
|
createFragmentInstance: (_fiber) => null,
|
|
@@ -14138,6 +14272,7 @@ function createRoot(canvas) {
|
|
|
14138
14272
|
const lastConfiguredProps = {};
|
|
14139
14273
|
let configured = false;
|
|
14140
14274
|
let pending = null;
|
|
14275
|
+
let rendererSetup = null;
|
|
14141
14276
|
return {
|
|
14142
14277
|
async configure(props = {}) {
|
|
14143
14278
|
let resolve;
|
|
@@ -14168,7 +14303,7 @@ function createRoot(canvas) {
|
|
|
14168
14303
|
forceEven
|
|
14169
14304
|
} = props;
|
|
14170
14305
|
const textureColorSpace = is.obj(glConfig) && !is.fun(glConfig) && !isRenderer(glConfig) && glConfig.textureColorSpace || is.obj(rendererConfig) && !is.fun(rendererConfig) && !isRenderer(rendererConfig) && rendererConfig.textureColorSpace || SRGBColorSpace;
|
|
14171
|
-
|
|
14306
|
+
let state = store.getState();
|
|
14172
14307
|
const defaultGLProps = {
|
|
14173
14308
|
canvas,
|
|
14174
14309
|
powerPreference: "high-performance",
|
|
@@ -14196,56 +14331,68 @@ function createRoot(canvas) {
|
|
|
14196
14331
|
"The `primaryCanvas` prop for multi-canvas rendering cannot be used with WebGL. Remove the `gl` prop or use WebGPU."
|
|
14197
14332
|
);
|
|
14198
14333
|
}
|
|
14199
|
-
if (
|
|
14200
|
-
|
|
14201
|
-
|
|
14202
|
-
|
|
14203
|
-
|
|
14204
|
-
|
|
14205
|
-
|
|
14206
|
-
|
|
14207
|
-
|
|
14208
|
-
|
|
14209
|
-
|
|
14210
|
-
|
|
14211
|
-
|
|
14212
|
-
|
|
14213
|
-
|
|
14214
|
-
|
|
14215
|
-
|
|
14216
|
-
|
|
14217
|
-
|
|
14218
|
-
|
|
14219
|
-
|
|
14220
|
-
|
|
14221
|
-
|
|
14222
|
-
|
|
14223
|
-
|
|
14224
|
-
|
|
14225
|
-
|
|
14226
|
-
|
|
14227
|
-
|
|
14228
|
-
|
|
14229
|
-
|
|
14230
|
-
|
|
14231
|
-
|
|
14232
|
-
|
|
14233
|
-
|
|
14234
|
-
|
|
14235
|
-
|
|
14236
|
-
|
|
14237
|
-
|
|
14238
|
-
|
|
14239
|
-
|
|
14240
|
-
|
|
14241
|
-
|
|
14242
|
-
|
|
14243
|
-
|
|
14244
|
-
|
|
14245
|
-
|
|
14334
|
+
if (!state.internal.actualRenderer) {
|
|
14335
|
+
if (!rendererSetup) {
|
|
14336
|
+
rendererSetup = (async () => {
|
|
14337
|
+
if (wantsGL) {
|
|
14338
|
+
renderer = await resolveRenderer(glConfig, defaultGLProps, WebGLRenderer);
|
|
14339
|
+
state.internal.actualRenderer = renderer;
|
|
14340
|
+
state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
|
|
14341
|
+
} else if (!wantsGL && primaryCanvas) {
|
|
14342
|
+
const primary = await waitForPrimary(primaryCanvas);
|
|
14343
|
+
renderer = primary.renderer;
|
|
14344
|
+
state.internal.actualRenderer = renderer;
|
|
14345
|
+
const canvasTarget = new CanvasTarget(canvas);
|
|
14346
|
+
primary.store.setState((prev) => ({
|
|
14347
|
+
internal: { ...prev.internal, isMultiCanvas: true }
|
|
14348
|
+
}));
|
|
14349
|
+
state.set((prev) => ({
|
|
14350
|
+
webGPUSupported: primary.store.getState().webGPUSupported,
|
|
14351
|
+
renderer,
|
|
14352
|
+
primaryStore: primary.store,
|
|
14353
|
+
internal: {
|
|
14354
|
+
...prev.internal,
|
|
14355
|
+
canvasTarget,
|
|
14356
|
+
isMultiCanvas: true,
|
|
14357
|
+
isSecondary: true,
|
|
14358
|
+
targetId: primaryCanvas
|
|
14359
|
+
}
|
|
14360
|
+
}));
|
|
14361
|
+
} else if (!wantsGL) {
|
|
14362
|
+
renderer = await resolveRenderer(rendererConfig, defaultGPUProps, WebGPURenderer);
|
|
14363
|
+
if (!renderer.hasInitialized?.()) {
|
|
14364
|
+
const size2 = computeInitialSize(canvas, propsSize);
|
|
14365
|
+
if (size2.width > 0 && size2.height > 0) {
|
|
14366
|
+
const pixelRatio = calculateDpr(dpr);
|
|
14367
|
+
canvas.width = size2.width * pixelRatio;
|
|
14368
|
+
canvas.height = size2.height * pixelRatio;
|
|
14369
|
+
}
|
|
14370
|
+
await renderer.init();
|
|
14371
|
+
}
|
|
14372
|
+
const backend = renderer.backend;
|
|
14373
|
+
const isWebGPUBackend = backend && "isWebGPUBackend" in backend;
|
|
14374
|
+
state.internal.actualRenderer = renderer;
|
|
14375
|
+
state.set({ webGPUSupported: isWebGPUBackend, renderer, primaryStore: store });
|
|
14376
|
+
if (canvasId && !state.internal.isSecondary) {
|
|
14377
|
+
const canvasTarget = new CanvasTarget(canvas);
|
|
14378
|
+
const unregisterPrimary = registerPrimary(canvasId, renderer, store);
|
|
14379
|
+
state.set((prev) => ({
|
|
14380
|
+
internal: {
|
|
14381
|
+
...prev.internal,
|
|
14382
|
+
canvasTarget,
|
|
14383
|
+
unregisterPrimary
|
|
14384
|
+
}
|
|
14385
|
+
}));
|
|
14386
|
+
}
|
|
14246
14387
|
}
|
|
14247
|
-
}))
|
|
14388
|
+
})().catch((err) => {
|
|
14389
|
+
rendererSetup = null;
|
|
14390
|
+
throw err;
|
|
14391
|
+
});
|
|
14248
14392
|
}
|
|
14393
|
+
await rendererSetup;
|
|
14394
|
+
state = store.getState();
|
|
14395
|
+
renderer = state.internal.actualRenderer;
|
|
14249
14396
|
}
|
|
14250
14397
|
let raycaster = state.raycaster;
|
|
14251
14398
|
if (!raycaster) state.set({ raycaster: raycaster = new Raycaster() });
|
|
@@ -14595,7 +14742,8 @@ function unmountComponentAtNode(canvas, callback) {
|
|
|
14595
14742
|
dispose(state.scene);
|
|
14596
14743
|
_roots.delete(canvas);
|
|
14597
14744
|
if (callback) callback(canvas);
|
|
14598
|
-
} catch {
|
|
14745
|
+
} catch (error) {
|
|
14746
|
+
console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
|
|
14599
14747
|
}
|
|
14600
14748
|
}, 500);
|
|
14601
14749
|
}
|
|
@@ -14658,6 +14806,7 @@ function PortalInner({ state = {}, children, container }) {
|
|
|
14658
14806
|
viewport = rootState.viewport.getCurrentViewport(camera, new Vector3(), resolvedSize);
|
|
14659
14807
|
if (camera !== rootState.camera) updateCamera(camera, resolvedSize);
|
|
14660
14808
|
}
|
|
14809
|
+
const set = injectState.set;
|
|
14661
14810
|
return {
|
|
14662
14811
|
// The intersect consists of the previous root state
|
|
14663
14812
|
...rootState,
|
|
@@ -14676,7 +14825,7 @@ function PortalInner({ state = {}, children, container }) {
|
|
|
14676
14825
|
size: resolvedSize,
|
|
14677
14826
|
viewport: { ...rootState.viewport, ...viewport },
|
|
14678
14827
|
// Layers are allowed to override events
|
|
14679
|
-
setEvents: (events2) =>
|
|
14828
|
+
setEvents: (events2) => set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
|
|
14680
14829
|
// Container for child attachment - the portalScene (injected or container itself)
|
|
14681
14830
|
internal: { ...rootState.internal, ...injectState.internal, container: portalScene }
|
|
14682
14831
|
};
|
|
@@ -14748,14 +14897,36 @@ function parseRendererConfig(rendererProp) {
|
|
|
14748
14897
|
return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
|
|
14749
14898
|
}
|
|
14750
14899
|
|
|
14900
|
+
const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
|
|
14901
|
+
const registries = /* @__PURE__ */ new WeakMap();
|
|
14902
|
+
function getKindRegistry(store, kind) {
|
|
14903
|
+
let registry = registries.get(store);
|
|
14904
|
+
if (!registry) {
|
|
14905
|
+
registry = {
|
|
14906
|
+
nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14907
|
+
uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14908
|
+
buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14909
|
+
gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
|
|
14910
|
+
};
|
|
14911
|
+
registries.set(store, registry);
|
|
14912
|
+
}
|
|
14913
|
+
return registry[kind];
|
|
14914
|
+
}
|
|
14915
|
+
function invalidateResource(store, kind, scopeKey) {
|
|
14916
|
+
const registry = getKindRegistry(store, kind);
|
|
14917
|
+
{
|
|
14918
|
+
registry.valid.clear();
|
|
14919
|
+
registry.staged.clear();
|
|
14920
|
+
}
|
|
14921
|
+
}
|
|
14922
|
+
function invalidateAllResources(store) {
|
|
14923
|
+
for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
|
|
14924
|
+
}
|
|
14925
|
+
|
|
14751
14926
|
function clearHmrCaches(store) {
|
|
14752
|
-
store.
|
|
14753
|
-
|
|
14754
|
-
|
|
14755
|
-
buffers: {},
|
|
14756
|
-
gpuStorage: {},
|
|
14757
|
-
_hmrVersion: state._hmrVersion + 1
|
|
14758
|
-
}));
|
|
14927
|
+
const primary = store.getState().primaryStore ?? store;
|
|
14928
|
+
invalidateAllResources(primary);
|
|
14929
|
+
primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
|
|
14759
14930
|
}
|
|
14760
14931
|
|
|
14761
14932
|
function CanvasImpl({
|
|
@@ -14836,6 +15007,7 @@ function CanvasImpl({
|
|
|
14836
15007
|
const handleDropMissed = useMutableCallback(onDropMissed);
|
|
14837
15008
|
const [block, setBlock] = React.useState(false);
|
|
14838
15009
|
const [error, setError] = React.useState(false);
|
|
15010
|
+
const [fallbackVisible, setFallbackVisible] = React.useState(false);
|
|
14839
15011
|
if (block) throw block;
|
|
14840
15012
|
if (error) throw error;
|
|
14841
15013
|
const root = React.useRef(null);
|
|
@@ -14843,6 +15015,7 @@ function CanvasImpl({
|
|
|
14843
15015
|
const unsubscribeErrorRef = React.useRef(null);
|
|
14844
15016
|
useIsomorphicLayoutEffect(() => {
|
|
14845
15017
|
effectActiveRef.current = true;
|
|
15018
|
+
if (fallbackVisible) return;
|
|
14846
15019
|
const canvas = canvasRef.current;
|
|
14847
15020
|
if (effectiveSize.width > 0 && effectiveSize.height > 0 && canvas) {
|
|
14848
15021
|
if (!root.current) {
|
|
@@ -14863,7 +15036,7 @@ function CanvasImpl({
|
|
|
14863
15036
|
}
|
|
14864
15037
|
async function run() {
|
|
14865
15038
|
if (!effectActiveRef.current || !root.current) return;
|
|
14866
|
-
await root.current.configure({
|
|
15039
|
+
const configured = await root.current.configure({
|
|
14867
15040
|
id,
|
|
14868
15041
|
primaryCanvas,
|
|
14869
15042
|
scheduler,
|
|
@@ -14904,8 +15077,20 @@ function CanvasImpl({
|
|
|
14904
15077
|
}
|
|
14905
15078
|
onCreated?.(state);
|
|
14906
15079
|
}
|
|
14907
|
-
})
|
|
14908
|
-
|
|
15080
|
+
}).then(
|
|
15081
|
+
() => true,
|
|
15082
|
+
// Renderer setup failed (e.g. no WebGL/WebGPU support). The `fallback` prop lives
|
|
15083
|
+
// inside <canvas>, which browsers don't display, so surface it as visible DOM
|
|
15084
|
+
// instead; with no fallback, rethrow to an external error boundary. (#3757)
|
|
15085
|
+
(setupError) => {
|
|
15086
|
+
if (effectActiveRef.current) {
|
|
15087
|
+
if (fallback != null) setFallbackVisible(true);
|
|
15088
|
+
else setError(setupError);
|
|
15089
|
+
}
|
|
15090
|
+
return false;
|
|
15091
|
+
}
|
|
15092
|
+
);
|
|
15093
|
+
if (!configured || !effectActiveRef.current || !root.current) return;
|
|
14909
15094
|
root.current.render(
|
|
14910
15095
|
/* @__PURE__ */ jsx(Bridge, { children: /* @__PURE__ */ jsx(ErrorBoundary, { set: setError, children: /* @__PURE__ */ jsxs(React.Suspense, { fallback: /* @__PURE__ */ jsx(Block, { set: setBlock }), children: [
|
|
14911
15096
|
backgroundProps && /* @__PURE__ */ jsx(Environment, { ...backgroundProps }),
|
|
@@ -14968,7 +15153,11 @@ function CanvasImpl({
|
|
|
14968
15153
|
...style
|
|
14969
15154
|
},
|
|
14970
15155
|
...props,
|
|
14971
|
-
children:
|
|
15156
|
+
children: fallbackVisible ? (
|
|
15157
|
+
// Renderer setup failed: render the fallback as visible DOM. Inside <canvas> (below)
|
|
15158
|
+
// it exists in the tree but browsers never paint it, which is the whole bug (#3757).
|
|
15159
|
+
fallback
|
|
15160
|
+
) : /* @__PURE__ */ jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx(
|
|
14972
15161
|
"canvas",
|
|
14973
15162
|
{
|
|
14974
15163
|
ref: canvasRef,
|
|
@@ -14987,4 +15176,4 @@ function Canvas(props) {
|
|
|
14987
15176
|
|
|
14988
15177
|
extend(THREE);
|
|
14989
15178
|
|
|
14990
|
-
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,
|
|
15179
|
+
export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
|