@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/legacy.cjs
CHANGED
|
@@ -62,9 +62,12 @@ const WebGPURenderer = class WebGPURenderer2 {
|
|
|
62
62
|
}
|
|
63
63
|
};
|
|
64
64
|
const RenderTarget = null;
|
|
65
|
+
const CubeRenderTarget = null;
|
|
65
66
|
|
|
66
67
|
const THREE = /*#__PURE__*/_mergeNamespaces({
|
|
67
68
|
__proto__: null,
|
|
69
|
+
CubeRenderTarget: CubeRenderTarget,
|
|
70
|
+
CubeRenderTargetCompat: three.WebGLCubeRenderTarget,
|
|
68
71
|
Inspector: Inspector,
|
|
69
72
|
R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
|
|
70
73
|
R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
|
|
@@ -342,15 +345,16 @@ function EnvironmentPortal({
|
|
|
342
345
|
preset = void 0,
|
|
343
346
|
extensions
|
|
344
347
|
}) {
|
|
345
|
-
const
|
|
348
|
+
const renderer = fiber.useThree((state) => state.renderer);
|
|
349
|
+
const isLegacy = fiber.useThree((state) => state.isLegacy);
|
|
346
350
|
const defaultScene = fiber.useThree((state) => state.scene);
|
|
347
351
|
const camera = React__namespace.useRef(null);
|
|
348
352
|
const [virtualScene] = React__namespace.useState(() => new three.Scene());
|
|
349
353
|
const fbo = React__namespace.useMemo(() => {
|
|
350
|
-
const fbo2 = new three.WebGLCubeRenderTarget(resolution);
|
|
354
|
+
const fbo2 = isLegacy ? new three.WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
|
|
351
355
|
fbo2.texture.type = three.HalfFloatType;
|
|
352
356
|
return fbo2;
|
|
353
|
-
}, [resolution]);
|
|
357
|
+
}, [resolution, isLegacy]);
|
|
354
358
|
React__namespace.useEffect(() => {
|
|
355
359
|
return () => {
|
|
356
360
|
fbo.dispose();
|
|
@@ -358,10 +362,10 @@ function EnvironmentPortal({
|
|
|
358
362
|
}, [fbo]);
|
|
359
363
|
React__namespace.useLayoutEffect(() => {
|
|
360
364
|
if (frames === 1) {
|
|
361
|
-
const autoClear =
|
|
362
|
-
|
|
363
|
-
camera.current.update(
|
|
364
|
-
|
|
365
|
+
const autoClear = renderer.autoClear;
|
|
366
|
+
renderer.autoClear = true;
|
|
367
|
+
camera.current.update(renderer, virtualScene);
|
|
368
|
+
renderer.autoClear = autoClear;
|
|
365
369
|
}
|
|
366
370
|
return setEnvProps(background, scene, defaultScene, fbo.texture, {
|
|
367
371
|
backgroundBlurriness: blur ?? backgroundBlurriness,
|
|
@@ -378,7 +382,7 @@ function EnvironmentPortal({
|
|
|
378
382
|
defaultScene,
|
|
379
383
|
background,
|
|
380
384
|
frames,
|
|
381
|
-
|
|
385
|
+
renderer,
|
|
382
386
|
blur,
|
|
383
387
|
backgroundBlurriness,
|
|
384
388
|
backgroundIntensity,
|
|
@@ -389,10 +393,10 @@ function EnvironmentPortal({
|
|
|
389
393
|
let count = 1;
|
|
390
394
|
fiber.useFrame(() => {
|
|
391
395
|
if (frames === Infinity || count < frames) {
|
|
392
|
-
const autoClear =
|
|
393
|
-
|
|
394
|
-
camera.current.update(
|
|
395
|
-
|
|
396
|
+
const autoClear = renderer.autoClear;
|
|
397
|
+
renderer.autoClear = true;
|
|
398
|
+
camera.current.update(renderer, virtualScene);
|
|
399
|
+
renderer.autoClear = autoClear;
|
|
396
400
|
count++;
|
|
397
401
|
}
|
|
398
402
|
});
|
|
@@ -459,7 +463,6 @@ function Environment(props) {
|
|
|
459
463
|
var __defProp = Object.defineProperty;
|
|
460
464
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
461
465
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
462
|
-
const act = React__namespace["act"];
|
|
463
466
|
const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React__namespace.useLayoutEffect : React__namespace.useEffect;
|
|
464
467
|
function useMutableCallback(fn) {
|
|
465
468
|
const ref = React__namespace.useRef(fn);
|
|
@@ -635,8 +638,7 @@ function prepare(target, root, type, props) {
|
|
|
635
638
|
object,
|
|
636
639
|
eventCount: 0,
|
|
637
640
|
handlers: {},
|
|
638
|
-
isHidden: false
|
|
639
|
-
deferredRefs: []
|
|
641
|
+
isHidden: false
|
|
640
642
|
};
|
|
641
643
|
if (object) object.__r3f = instance;
|
|
642
644
|
}
|
|
@@ -793,6 +795,17 @@ function unregisterVisibility(store, object) {
|
|
|
793
795
|
internal.visibilityRegistry.delete(object.uuid);
|
|
794
796
|
internal.occlusionCache.delete(object);
|
|
795
797
|
}
|
|
798
|
+
function updateVisibilityHandlers(store, object, handlers) {
|
|
799
|
+
const { internal } = store.getState();
|
|
800
|
+
const entry = internal.visibilityRegistry.get(object.uuid);
|
|
801
|
+
if (!entry) return false;
|
|
802
|
+
entry.handlers = handlers;
|
|
803
|
+
if ((handlers.onOccluded || handlers.onVisible) && !internal.occlusionEnabled) {
|
|
804
|
+
object.occlusionTest = true;
|
|
805
|
+
enableOcclusion(store);
|
|
806
|
+
}
|
|
807
|
+
return true;
|
|
808
|
+
}
|
|
796
809
|
function checkVisibility(state) {
|
|
797
810
|
const { internal, camera } = state;
|
|
798
811
|
const registry = internal.visibilityRegistry;
|
|
@@ -953,9 +966,9 @@ function diffProps(instance, newProps) {
|
|
|
953
966
|
const { root, key } = resolve(instance.object, prop);
|
|
954
967
|
if (root.constructor && root.constructor.length === 0) {
|
|
955
968
|
const ctor = getMemoizedPrototype(root);
|
|
956
|
-
if (!is.und(ctor)) changedProps[
|
|
969
|
+
if (!is.und(ctor)) changedProps[prop] = ctor[key];
|
|
957
970
|
} else {
|
|
958
|
-
changedProps[
|
|
971
|
+
changedProps[prop] = 0;
|
|
959
972
|
}
|
|
960
973
|
}
|
|
961
974
|
return changedProps;
|
|
@@ -980,10 +993,7 @@ function applyProps(object, props) {
|
|
|
980
993
|
continue;
|
|
981
994
|
}
|
|
982
995
|
if (value === void 0) continue;
|
|
983
|
-
if (isFromRef(value))
|
|
984
|
-
instance?.deferredRefs?.push({ prop, ref: value[FROM_REF] });
|
|
985
|
-
continue;
|
|
986
|
-
}
|
|
996
|
+
if (isFromRef(value)) continue;
|
|
987
997
|
if (isOnce(value)) {
|
|
988
998
|
if (instance?.appliedOnce?.has(prop)) continue;
|
|
989
999
|
if (instance) {
|
|
@@ -1019,6 +1029,19 @@ function applyProps(object, props) {
|
|
|
1019
1029
|
} else if (isVectorLike(target) && is.num(value)) {
|
|
1020
1030
|
if ("setScalar" in target && typeof target.setScalar === "function") target.setScalar(value);
|
|
1021
1031
|
else target.set(value);
|
|
1032
|
+
} else if (root instanceof three.ShaderMaterial && key === "uniforms" && is.obj(value)) {
|
|
1033
|
+
if (!is.obj(root.uniforms)) root.uniforms = {};
|
|
1034
|
+
const uniforms = root.uniforms;
|
|
1035
|
+
const nextUniforms = value;
|
|
1036
|
+
for (const name in nextUniforms) {
|
|
1037
|
+
const uniform = nextUniforms[name];
|
|
1038
|
+
const targetUniform = uniforms[name];
|
|
1039
|
+
if (targetUniform) Object.assign(targetUniform, uniform);
|
|
1040
|
+
else {
|
|
1041
|
+
const nextUniform = uniform instanceof three.Uniform ? uniform.clone() : new three.Uniform(uniform.value);
|
|
1042
|
+
uniforms[name] = nextUniform;
|
|
1043
|
+
}
|
|
1044
|
+
}
|
|
1022
1045
|
} else {
|
|
1023
1046
|
root[key] = value;
|
|
1024
1047
|
if (key.endsWith("Node") && root.isMaterial) {
|
|
@@ -1037,6 +1060,9 @@ function applyProps(object, props) {
|
|
|
1037
1060
|
if (instance.eventCount && object2.raycast !== null) {
|
|
1038
1061
|
rootState.internal.interaction.push(object2);
|
|
1039
1062
|
}
|
|
1063
|
+
}
|
|
1064
|
+
if (instance?.parent && rootState?.internal && instance.object?.isObject3D) {
|
|
1065
|
+
const object2 = instance.object;
|
|
1040
1066
|
const root = findInitialRoot(instance);
|
|
1041
1067
|
const visibilityHandlers = {
|
|
1042
1068
|
onFramed: instance.handlers.onFramed,
|
|
@@ -1044,7 +1070,9 @@ function applyProps(object, props) {
|
|
|
1044
1070
|
onVisible: instance.handlers.onVisible
|
|
1045
1071
|
};
|
|
1046
1072
|
if (hasVisibilityHandlers(visibilityHandlers)) {
|
|
1047
|
-
|
|
1073
|
+
if (!updateVisibilityHandlers(root, object2, visibilityHandlers)) {
|
|
1074
|
+
registerVisibility(root, object2, visibilityHandlers);
|
|
1075
|
+
}
|
|
1048
1076
|
} else {
|
|
1049
1077
|
unregisterVisibility(root, object2);
|
|
1050
1078
|
}
|
|
@@ -1572,6 +1600,7 @@ function createPointerEvents(store) {
|
|
|
1572
1600
|
set((state) => ({ events: { ...state.events, connected: void 0 } }));
|
|
1573
1601
|
}
|
|
1574
1602
|
},
|
|
1603
|
+
// PREVIEW (A8): the XR pointer registration API may change before stable.
|
|
1575
1604
|
registerPointer: (config) => {
|
|
1576
1605
|
const pointerId = nextXRPointerId++;
|
|
1577
1606
|
xrPointers.set(pointerId, config);
|
|
@@ -1659,11 +1688,10 @@ function notifyAlpha({ message, link }) {
|
|
|
1659
1688
|
}
|
|
1660
1689
|
|
|
1661
1690
|
const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
|
|
1662
|
-
const INTERNAL_FIBER_MARKERS = ["packages/fiber/src", "packages/fiber/dist", "@react-three/fiber", "@react-three_fiber"];
|
|
1663
1691
|
function isInternalRendererAccess(stack, callerDepth = 2) {
|
|
1664
1692
|
if (!stack) return false;
|
|
1665
1693
|
const caller = stack.split("\n")[callerDepth] ?? "";
|
|
1666
|
-
return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m))
|
|
1694
|
+
return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
|
|
1667
1695
|
}
|
|
1668
1696
|
|
|
1669
1697
|
const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
|
|
@@ -1798,6 +1826,7 @@ const createStore = (invalidate, advance) => {
|
|
|
1798
1826
|
}),
|
|
1799
1827
|
setFrameloop: (frameloop = "always") => {
|
|
1800
1828
|
set(() => ({ frameloop }));
|
|
1829
|
+
scheduler.getScheduler().frameloop = frameloop;
|
|
1801
1830
|
},
|
|
1802
1831
|
setError: (error) => set(() => ({ error })),
|
|
1803
1832
|
error: null,
|
|
@@ -1978,19 +2007,25 @@ function loadingFn(extensions, onProgress) {
|
|
|
1978
2007
|
);
|
|
1979
2008
|
};
|
|
1980
2009
|
}
|
|
1981
|
-
function useLoader(loader, input, extensions, onProgress) {
|
|
1982
|
-
const
|
|
2010
|
+
function useLoader(loader, input, extensions, onProgress, cacheKey) {
|
|
2011
|
+
const inputs = Array.isArray(input) ? input : [input];
|
|
2012
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
1983
2013
|
const fn = loadingFn(extensions, onProgress);
|
|
1984
|
-
const results =
|
|
2014
|
+
const results = cacheKeys.map(
|
|
2015
|
+
(key, index) => suspendReact.suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
|
|
2016
|
+
);
|
|
1985
2017
|
return Array.isArray(input) ? results : results[0];
|
|
1986
2018
|
}
|
|
1987
|
-
useLoader.preload = function(loader, input, extensions, onProgress) {
|
|
1988
|
-
const
|
|
1989
|
-
|
|
2019
|
+
useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
|
|
2020
|
+
const inputs = Array.isArray(input) ? input : [input];
|
|
2021
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
2022
|
+
cacheKeys.forEach(
|
|
2023
|
+
(key, index) => suspendReact.preload(() => loadingFn(extensions, onProgress)(loader, inputs[index]), [loader, key])
|
|
2024
|
+
);
|
|
1990
2025
|
};
|
|
1991
|
-
useLoader.clear = function(loader, input) {
|
|
1992
|
-
const
|
|
1993
|
-
|
|
2026
|
+
useLoader.clear = function(loader, input, cacheKey) {
|
|
2027
|
+
const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
|
|
2028
|
+
cacheKeys.forEach((key) => suspendReact.clear([loader, key]));
|
|
1994
2029
|
};
|
|
1995
2030
|
useLoader.loader = getLoader;
|
|
1996
2031
|
|
|
@@ -2410,7 +2445,7 @@ function advance(timestamp) {
|
|
|
2410
2445
|
scheduler.getScheduler().step(timestamp);
|
|
2411
2446
|
}
|
|
2412
2447
|
|
|
2413
|
-
const version = "10.0.0-alpha.
|
|
2448
|
+
const version = "10.0.0-alpha.3";
|
|
2414
2449
|
const packageData = {
|
|
2415
2450
|
version: version};
|
|
2416
2451
|
|
|
@@ -13666,7 +13701,7 @@ function n0() {
|
|
|
13666
13701
|
var t0 = n0();
|
|
13667
13702
|
const r0 = Xb(t0);
|
|
13668
13703
|
|
|
13669
|
-
const t = 1, o = 8, r = 32, e = 2;
|
|
13704
|
+
const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
|
|
13670
13705
|
|
|
13671
13706
|
function createReconciler(config) {
|
|
13672
13707
|
const reconciler2 = r0(config);
|
|
@@ -13831,7 +13866,15 @@ function setFiberRef(fiber, publicInstance) {
|
|
|
13831
13866
|
}
|
|
13832
13867
|
}
|
|
13833
13868
|
const reconstructed = [];
|
|
13834
|
-
function
|
|
13869
|
+
function flushReconstructedInstances() {
|
|
13870
|
+
if (reconstructed.length === 0) return;
|
|
13871
|
+
try {
|
|
13872
|
+
swapReconstructedInstances();
|
|
13873
|
+
} finally {
|
|
13874
|
+
reconstructed.length = 0;
|
|
13875
|
+
}
|
|
13876
|
+
}
|
|
13877
|
+
function swapReconstructedInstances() {
|
|
13835
13878
|
for (const [instance] of reconstructed) {
|
|
13836
13879
|
const parent = instance.parent;
|
|
13837
13880
|
if (parent) {
|
|
@@ -13849,6 +13892,7 @@ function swapInstances() {
|
|
|
13849
13892
|
}
|
|
13850
13893
|
}
|
|
13851
13894
|
if (instance.isHidden) unhideInstance(instance);
|
|
13895
|
+
if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
|
|
13852
13896
|
if (instance.object.__r3f) delete instance.object.__r3f;
|
|
13853
13897
|
if (instance.type !== "primitive") disposeOnIdle(instance.object);
|
|
13854
13898
|
}
|
|
@@ -13861,6 +13905,8 @@ function swapInstances() {
|
|
|
13861
13905
|
instance.object.__r3f = instance;
|
|
13862
13906
|
setFiberRef(fiber, instance.object);
|
|
13863
13907
|
delete instance.appliedOnce;
|
|
13908
|
+
instance.eventCount = 0;
|
|
13909
|
+
instance.handlers = {};
|
|
13864
13910
|
applyProps(instance.object, instance.props);
|
|
13865
13911
|
if (instance.props.attach) {
|
|
13866
13912
|
attach(parent, instance);
|
|
@@ -13877,14 +13923,114 @@ function swapInstances() {
|
|
|
13877
13923
|
invalidateInstance(instance);
|
|
13878
13924
|
}
|
|
13879
13925
|
}
|
|
13880
|
-
reconstructed.length = 0;
|
|
13881
13926
|
}
|
|
13882
13927
|
const handleTextInstance = () => {
|
|
13883
13928
|
};
|
|
13884
13929
|
const NO_CONTEXT = {};
|
|
13885
13930
|
let currentUpdatePriority = NoEventPriority;
|
|
13886
|
-
|
|
13887
|
-
|
|
13931
|
+
function getEventPriority(type) {
|
|
13932
|
+
switch (type) {
|
|
13933
|
+
case "beforetoggle":
|
|
13934
|
+
case "cancel":
|
|
13935
|
+
case "click":
|
|
13936
|
+
case "close":
|
|
13937
|
+
case "contextmenu":
|
|
13938
|
+
case "copy":
|
|
13939
|
+
case "cut":
|
|
13940
|
+
case "auxclick":
|
|
13941
|
+
case "dblclick":
|
|
13942
|
+
case "dragend":
|
|
13943
|
+
case "dragstart":
|
|
13944
|
+
case "drop":
|
|
13945
|
+
case "focusin":
|
|
13946
|
+
case "focusout":
|
|
13947
|
+
case "input":
|
|
13948
|
+
case "invalid":
|
|
13949
|
+
case "keydown":
|
|
13950
|
+
case "keypress":
|
|
13951
|
+
case "keyup":
|
|
13952
|
+
case "mousedown":
|
|
13953
|
+
case "mouseup":
|
|
13954
|
+
case "paste":
|
|
13955
|
+
case "pause":
|
|
13956
|
+
case "play":
|
|
13957
|
+
case "pointercancel":
|
|
13958
|
+
case "pointerdown":
|
|
13959
|
+
case "pointerup":
|
|
13960
|
+
case "ratechange":
|
|
13961
|
+
case "reset":
|
|
13962
|
+
case "resize":
|
|
13963
|
+
case "seeked":
|
|
13964
|
+
case "submit":
|
|
13965
|
+
case "touchcancel":
|
|
13966
|
+
case "touchend":
|
|
13967
|
+
case "touchstart":
|
|
13968
|
+
case "volumechange":
|
|
13969
|
+
case "change":
|
|
13970
|
+
case "selectionchange":
|
|
13971
|
+
case "compositionstart":
|
|
13972
|
+
case "compositionend":
|
|
13973
|
+
case "compositionupdate":
|
|
13974
|
+
case "beforeinput":
|
|
13975
|
+
case "blur":
|
|
13976
|
+
case "fullscreenchange":
|
|
13977
|
+
case "focus":
|
|
13978
|
+
case "hashchange":
|
|
13979
|
+
case "popstate":
|
|
13980
|
+
case "select":
|
|
13981
|
+
case "selectstart":
|
|
13982
|
+
return e;
|
|
13983
|
+
case "drag":
|
|
13984
|
+
case "dragenter":
|
|
13985
|
+
case "dragexit":
|
|
13986
|
+
case "dragleave":
|
|
13987
|
+
case "dragover":
|
|
13988
|
+
case "mousemove":
|
|
13989
|
+
case "mouseout":
|
|
13990
|
+
case "mouseover":
|
|
13991
|
+
case "pointermove":
|
|
13992
|
+
case "pointerout":
|
|
13993
|
+
case "pointerover":
|
|
13994
|
+
case "scroll":
|
|
13995
|
+
case "touchmove":
|
|
13996
|
+
case "wheel":
|
|
13997
|
+
case "mouseenter":
|
|
13998
|
+
case "mouseleave":
|
|
13999
|
+
case "pointerenter":
|
|
14000
|
+
case "pointerleave":
|
|
14001
|
+
return o;
|
|
14002
|
+
case "message": {
|
|
14003
|
+
switch (Tb.unstable_getCurrentPriorityLevel()) {
|
|
14004
|
+
case Tb.unstable_ImmediatePriority:
|
|
14005
|
+
return e;
|
|
14006
|
+
case Tb.unstable_UserBlockingPriority:
|
|
14007
|
+
return o;
|
|
14008
|
+
case Tb.unstable_NormalPriority:
|
|
14009
|
+
case Tb.unstable_LowPriority:
|
|
14010
|
+
return r;
|
|
14011
|
+
case Tb.unstable_IdlePriority:
|
|
14012
|
+
return i$1;
|
|
14013
|
+
default:
|
|
14014
|
+
return r;
|
|
14015
|
+
}
|
|
14016
|
+
}
|
|
14017
|
+
default:
|
|
14018
|
+
return r;
|
|
14019
|
+
}
|
|
14020
|
+
}
|
|
14021
|
+
function scheduleMicrotask(callback) {
|
|
14022
|
+
if (typeof queueMicrotask === "function") {
|
|
14023
|
+
queueMicrotask(callback);
|
|
14024
|
+
} else if (typeof Promise !== "undefined") {
|
|
14025
|
+
Promise.resolve().then(callback).catch((error) => {
|
|
14026
|
+
setTimeout(() => {
|
|
14027
|
+
throw error;
|
|
14028
|
+
});
|
|
14029
|
+
});
|
|
14030
|
+
} else {
|
|
14031
|
+
setTimeout(callback);
|
|
14032
|
+
}
|
|
14033
|
+
}
|
|
13888
14034
|
const reconciler = /* @__PURE__ */ createReconciler({
|
|
13889
14035
|
isPrimaryRenderer: false,
|
|
13890
14036
|
warnsIfNotActing: false,
|
|
@@ -13923,16 +14069,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13923
14069
|
else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
|
|
13924
14070
|
else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
|
|
13925
14071
|
if (reconstruct) {
|
|
13926
|
-
reconstructed.push([instance,
|
|
14072
|
+
reconstructed.push([instance, getInstanceProps(newProps), fiber]);
|
|
13927
14073
|
} else {
|
|
13928
14074
|
const changedProps = diffProps(instance, newProps);
|
|
13929
|
-
|
|
13930
|
-
|
|
13931
|
-
|
|
13932
|
-
|
|
14075
|
+
const attach2 = instance.props.attach;
|
|
14076
|
+
instance.props = getInstanceProps(newProps);
|
|
14077
|
+
if (attach2 !== void 0) instance.props.attach = attach2;
|
|
14078
|
+
else delete instance.props.attach;
|
|
14079
|
+
if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
|
|
13933
14080
|
}
|
|
13934
|
-
const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
|
|
13935
|
-
if (isTailSibling) swapInstances();
|
|
13936
14081
|
},
|
|
13937
14082
|
finalizeInitialChildren: (instance) => {
|
|
13938
14083
|
for (const prop in instance.props) {
|
|
@@ -13957,8 +14102,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13957
14102
|
const target = container.getState().internal.container ?? container.getState().scene;
|
|
13958
14103
|
return prepare(target, container, "", {});
|
|
13959
14104
|
},
|
|
13960
|
-
|
|
13961
|
-
|
|
14105
|
+
// Reconstructed instances are swapped once all mutations are committed,
|
|
14106
|
+
// before layout effects run so refs point to the new objects
|
|
14107
|
+
resetAfterCommit: flushReconstructedInstances,
|
|
13962
14108
|
shouldSetTextContent: () => false,
|
|
13963
14109
|
clearContainer: () => false,
|
|
13964
14110
|
hideInstance,
|
|
@@ -13966,6 +14112,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
13966
14112
|
createTextInstance: handleTextInstance,
|
|
13967
14113
|
hideTextInstance: handleTextInstance,
|
|
13968
14114
|
unhideTextInstance: handleTextInstance,
|
|
14115
|
+
// Mirrors react-dom, which flushes discrete work in microtasks
|
|
14116
|
+
supportsMicrotasks: true,
|
|
14117
|
+
scheduleMicrotask,
|
|
13969
14118
|
scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
|
|
13970
14119
|
cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
|
|
13971
14120
|
noTimeout: -1,
|
|
@@ -14006,28 +14155,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
14006
14155
|
},
|
|
14007
14156
|
resolveUpdatePriority() {
|
|
14008
14157
|
if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
|
|
14009
|
-
|
|
14010
|
-
|
|
14011
|
-
|
|
14012
|
-
case "dblclick":
|
|
14013
|
-
case "dragenter":
|
|
14014
|
-
case "dragleave":
|
|
14015
|
-
case "drop":
|
|
14016
|
-
case "pointercancel":
|
|
14017
|
-
case "pointerdown":
|
|
14018
|
-
case "pointerup":
|
|
14019
|
-
return e;
|
|
14020
|
-
case "dragover":
|
|
14021
|
-
case "pointermove":
|
|
14022
|
-
case "pointerout":
|
|
14023
|
-
case "pointerover":
|
|
14024
|
-
case "pointerenter":
|
|
14025
|
-
case "pointerleave":
|
|
14026
|
-
case "wheel":
|
|
14027
|
-
return o;
|
|
14028
|
-
default:
|
|
14029
|
-
return r;
|
|
14030
|
-
}
|
|
14158
|
+
const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
|
|
14159
|
+
if (eventType === void 0) return r;
|
|
14160
|
+
return getEventPriority(eventType);
|
|
14031
14161
|
},
|
|
14032
14162
|
resetFormInstance() {
|
|
14033
14163
|
},
|
|
@@ -14076,11 +14206,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
|
|
|
14076
14206
|
cloneMutableTextInstance(textInstance) {
|
|
14077
14207
|
return textInstance;
|
|
14078
14208
|
},
|
|
14209
|
+
// React 19.2 added these for root-level view transitions. They only run for hosts that opt into
|
|
14210
|
+
// view transitions by returning a container from cloneRootViewTransitionContainer; R3F renders
|
|
14211
|
+
// into a WebGL/WebGPU canvas, where cloning the root has no meaning, so we never opt in and
|
|
14212
|
+
// React never calls them. They stay as no-ops rather than throws: the host config is shared by
|
|
14213
|
+
// every root, and a throw here would turn a React-internal probe into a hard crash for users.
|
|
14214
|
+
// Guarded by a test asserting a full render + unmount never reaches them.
|
|
14079
14215
|
cloneRootViewTransitionContainer(_rootContainer) {
|
|
14080
|
-
throw new Error("Not implemented.");
|
|
14081
14216
|
},
|
|
14082
14217
|
removeRootViewTransitionClone(_rootContainer, _clone) {
|
|
14083
|
-
throw new Error("Not implemented.");
|
|
14084
14218
|
},
|
|
14085
14219
|
// https://github.com/facebook/react/pull/32465
|
|
14086
14220
|
createFragmentInstance: (_fiber) => null,
|
|
@@ -14165,6 +14299,7 @@ function createRoot(canvas) {
|
|
|
14165
14299
|
const lastConfiguredProps = {};
|
|
14166
14300
|
let configured = false;
|
|
14167
14301
|
let pending = null;
|
|
14302
|
+
let rendererSetup = null;
|
|
14168
14303
|
return {
|
|
14169
14304
|
async configure(props = {}) {
|
|
14170
14305
|
let resolve;
|
|
@@ -14195,7 +14330,7 @@ function createRoot(canvas) {
|
|
|
14195
14330
|
forceEven
|
|
14196
14331
|
} = props;
|
|
14197
14332
|
const textureColorSpace = is.obj(glConfig) && !is.fun(glConfig) && !isRenderer(glConfig) && glConfig.textureColorSpace || is.obj(rendererConfig) && !is.fun(rendererConfig) && !isRenderer(rendererConfig) && rendererConfig.textureColorSpace || three.SRGBColorSpace;
|
|
14198
|
-
|
|
14333
|
+
let state = store.getState();
|
|
14199
14334
|
const defaultGLProps = {
|
|
14200
14335
|
canvas,
|
|
14201
14336
|
powerPreference: "high-performance",
|
|
@@ -14223,9 +14358,21 @@ function createRoot(canvas) {
|
|
|
14223
14358
|
);
|
|
14224
14359
|
}
|
|
14225
14360
|
if (!state.internal.actualRenderer) {
|
|
14226
|
-
|
|
14227
|
-
|
|
14228
|
-
|
|
14361
|
+
if (!rendererSetup) {
|
|
14362
|
+
rendererSetup = (async () => {
|
|
14363
|
+
{
|
|
14364
|
+
renderer = await resolveRenderer(glConfig, defaultGLProps, three.WebGLRenderer);
|
|
14365
|
+
state.internal.actualRenderer = renderer;
|
|
14366
|
+
state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
|
|
14367
|
+
}
|
|
14368
|
+
})().catch((err) => {
|
|
14369
|
+
rendererSetup = null;
|
|
14370
|
+
throw err;
|
|
14371
|
+
});
|
|
14372
|
+
}
|
|
14373
|
+
await rendererSetup;
|
|
14374
|
+
state = store.getState();
|
|
14375
|
+
renderer = state.internal.actualRenderer;
|
|
14229
14376
|
}
|
|
14230
14377
|
let raycaster = state.raycaster;
|
|
14231
14378
|
if (!raycaster) state.set({ raycaster: raycaster = new three.Raycaster() });
|
|
@@ -14575,7 +14722,8 @@ function unmountComponentAtNode(canvas, callback) {
|
|
|
14575
14722
|
dispose(state.scene);
|
|
14576
14723
|
_roots.delete(canvas);
|
|
14577
14724
|
if (callback) callback(canvas);
|
|
14578
|
-
} catch {
|
|
14725
|
+
} catch (error) {
|
|
14726
|
+
console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
|
|
14579
14727
|
}
|
|
14580
14728
|
}, 500);
|
|
14581
14729
|
}
|
|
@@ -14638,6 +14786,7 @@ function PortalInner({ state = {}, children, container }) {
|
|
|
14638
14786
|
viewport = rootState.viewport.getCurrentViewport(camera, new three.Vector3(), resolvedSize);
|
|
14639
14787
|
if (camera !== rootState.camera) updateCamera(camera, resolvedSize);
|
|
14640
14788
|
}
|
|
14789
|
+
const set = injectState.set;
|
|
14641
14790
|
return {
|
|
14642
14791
|
// The intersect consists of the previous root state
|
|
14643
14792
|
...rootState,
|
|
@@ -14656,7 +14805,7 @@ function PortalInner({ state = {}, children, container }) {
|
|
|
14656
14805
|
size: resolvedSize,
|
|
14657
14806
|
viewport: { ...rootState.viewport, ...viewport },
|
|
14658
14807
|
// Layers are allowed to override events
|
|
14659
|
-
setEvents: (events2) =>
|
|
14808
|
+
setEvents: (events2) => set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
|
|
14660
14809
|
// Container for child attachment - the portalScene (injected or container itself)
|
|
14661
14810
|
internal: { ...rootState.internal, ...injectState.internal, container: portalScene }
|
|
14662
14811
|
};
|
|
@@ -14728,14 +14877,36 @@ function parseRendererConfig(rendererProp) {
|
|
|
14728
14877
|
return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
|
|
14729
14878
|
}
|
|
14730
14879
|
|
|
14880
|
+
const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
|
|
14881
|
+
const registries = /* @__PURE__ */ new WeakMap();
|
|
14882
|
+
function getKindRegistry(store, kind) {
|
|
14883
|
+
let registry = registries.get(store);
|
|
14884
|
+
if (!registry) {
|
|
14885
|
+
registry = {
|
|
14886
|
+
nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14887
|
+
uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14888
|
+
buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
|
|
14889
|
+
gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
|
|
14890
|
+
};
|
|
14891
|
+
registries.set(store, registry);
|
|
14892
|
+
}
|
|
14893
|
+
return registry[kind];
|
|
14894
|
+
}
|
|
14895
|
+
function invalidateResource(store, kind, scopeKey) {
|
|
14896
|
+
const registry = getKindRegistry(store, kind);
|
|
14897
|
+
{
|
|
14898
|
+
registry.valid.clear();
|
|
14899
|
+
registry.staged.clear();
|
|
14900
|
+
}
|
|
14901
|
+
}
|
|
14902
|
+
function invalidateAllResources(store) {
|
|
14903
|
+
for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
|
|
14904
|
+
}
|
|
14905
|
+
|
|
14731
14906
|
function clearHmrCaches(store) {
|
|
14732
|
-
store.
|
|
14733
|
-
|
|
14734
|
-
|
|
14735
|
-
buffers: {},
|
|
14736
|
-
gpuStorage: {},
|
|
14737
|
-
_hmrVersion: state._hmrVersion + 1
|
|
14738
|
-
}));
|
|
14907
|
+
const primary = store.getState().primaryStore ?? store;
|
|
14908
|
+
invalidateAllResources(primary);
|
|
14909
|
+
primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
|
|
14739
14910
|
}
|
|
14740
14911
|
|
|
14741
14912
|
function CanvasImpl({
|
|
@@ -14816,6 +14987,7 @@ function CanvasImpl({
|
|
|
14816
14987
|
const handleDropMissed = useMutableCallback(onDropMissed);
|
|
14817
14988
|
const [block, setBlock] = React__namespace.useState(false);
|
|
14818
14989
|
const [error, setError] = React__namespace.useState(false);
|
|
14990
|
+
const [fallbackVisible, setFallbackVisible] = React__namespace.useState(false);
|
|
14819
14991
|
if (block) throw block;
|
|
14820
14992
|
if (error) throw error;
|
|
14821
14993
|
const root = React__namespace.useRef(null);
|
|
@@ -14823,6 +14995,7 @@ function CanvasImpl({
|
|
|
14823
14995
|
const unsubscribeErrorRef = React__namespace.useRef(null);
|
|
14824
14996
|
useIsomorphicLayoutEffect(() => {
|
|
14825
14997
|
effectActiveRef.current = true;
|
|
14998
|
+
if (fallbackVisible) return;
|
|
14826
14999
|
const canvas = canvasRef.current;
|
|
14827
15000
|
if (effectiveSize.width > 0 && effectiveSize.height > 0 && canvas) {
|
|
14828
15001
|
if (!root.current) {
|
|
@@ -14843,7 +15016,7 @@ function CanvasImpl({
|
|
|
14843
15016
|
}
|
|
14844
15017
|
async function run() {
|
|
14845
15018
|
if (!effectActiveRef.current || !root.current) return;
|
|
14846
|
-
await root.current.configure({
|
|
15019
|
+
const configured = await root.current.configure({
|
|
14847
15020
|
id,
|
|
14848
15021
|
primaryCanvas,
|
|
14849
15022
|
scheduler,
|
|
@@ -14884,8 +15057,20 @@ function CanvasImpl({
|
|
|
14884
15057
|
}
|
|
14885
15058
|
onCreated?.(state);
|
|
14886
15059
|
}
|
|
14887
|
-
})
|
|
14888
|
-
|
|
15060
|
+
}).then(
|
|
15061
|
+
() => true,
|
|
15062
|
+
// Renderer setup failed (e.g. no WebGL/WebGPU support). The `fallback` prop lives
|
|
15063
|
+
// inside <canvas>, which browsers don't display, so surface it as visible DOM
|
|
15064
|
+
// instead; with no fallback, rethrow to an external error boundary. (#3757)
|
|
15065
|
+
(setupError) => {
|
|
15066
|
+
if (effectActiveRef.current) {
|
|
15067
|
+
if (fallback != null) setFallbackVisible(true);
|
|
15068
|
+
else setError(setupError);
|
|
15069
|
+
}
|
|
15070
|
+
return false;
|
|
15071
|
+
}
|
|
15072
|
+
);
|
|
15073
|
+
if (!configured || !effectActiveRef.current || !root.current) return;
|
|
14889
15074
|
root.current.render(
|
|
14890
15075
|
/* @__PURE__ */ jsxRuntime.jsx(Bridge, { children: /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { set: setError, children: /* @__PURE__ */ jsxRuntime.jsxs(React__namespace.Suspense, { fallback: /* @__PURE__ */ jsxRuntime.jsx(Block, { set: setBlock }), children: [
|
|
14891
15076
|
backgroundProps && /* @__PURE__ */ jsxRuntime.jsx(Environment, { ...backgroundProps }),
|
|
@@ -14948,7 +15133,11 @@ function CanvasImpl({
|
|
|
14948
15133
|
...style
|
|
14949
15134
|
},
|
|
14950
15135
|
...props,
|
|
14951
|
-
children:
|
|
15136
|
+
children: fallbackVisible ? (
|
|
15137
|
+
// Renderer setup failed: render the fallback as visible DOM. Inside <canvas> (below)
|
|
15138
|
+
// it exists in the tree but browsers never paint it, which is the whole bug (#3757).
|
|
15139
|
+
fallback
|
|
15140
|
+
) : /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsx(
|
|
14952
15141
|
"canvas",
|
|
14953
15142
|
{
|
|
14954
15143
|
ref: canvasRef,
|
|
@@ -14986,7 +15175,6 @@ exports.REACT_INTERNAL_PROPS = REACT_INTERNAL_PROPS;
|
|
|
14986
15175
|
exports.RESERVED_PROPS = RESERVED_PROPS;
|
|
14987
15176
|
exports.Texture = Texture;
|
|
14988
15177
|
exports._roots = _roots;
|
|
14989
|
-
exports.act = act;
|
|
14990
15178
|
exports.addAfterEffect = addAfterEffect;
|
|
14991
15179
|
exports.addEffect = addEffect;
|
|
14992
15180
|
exports.addTail = addTail;
|