@expofp/renderer 3.2.5 → 3.27.1

package/dist/space/Camera.js

@@ -0,0 +1,321 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { degToRad } from '@expofp/geometry';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useRef } from 'react';
+import { Box3, Vector3 } from 'three';
+import { useCameraControls } from '../controls';
+import { CAMERA_FOV, CameraContext, createCameraHandle, zoomIdentityDistance, } from './camera-handle';
+import { isPerspective } from './camera-kind';
+import { useCanvasSize } from './canvas-size';
+import { farPlane, MAX_PITCH, nearPlane } from './clipping';
+import { useSpace } from './Space';
+/**
+ * The camera the plan is drawn through, and the zoom that camera is read as.
+ *
+ * Everything the imperative renderer's camera system did, with one simplification the viewbox fit
+ * pays for: because {@link Space} sizes a world unit to a device pixel, the distance that frames the
+ * plan follows from the drawing buffer alone and none of the arithmetic here has to know what the
+ * scene holds. The near plane is the one exception, its guarantee being stated in plan units.
+ *
+ * **Zoom is the state and distance is derived.** The camera stores a distance, which the buffer
+ * height converts to a factor — so a resize would silently change the zoom if nothing held it. This
+ * remembers the factor and dollies back to it, which is what the imperative renderer kept a previous
+ * viewport height for; a user dolly writes the factor back on the controls' own update.
+ *
+ * **The one thing it needs from the scene is `space.scale`,** and only for the near plane. The
+ * imperative renderer kept its camera and scene independent because it applied its depth guarantee
+ * to world distances; that guarantee is stated in plan units, so converting it is what makes it hold
+ * on a plan drawn at any scale (see {@link nearPlane}). Nothing else here reads the scene.
+ *
+ * **All four limits are written here**, zoom and pitch alike, because they are the same kind of
+ * thing: a constraint on where the camera may go, holding for a programmatic move as much as for a
+ * dragged one. What the *user* may do is `Controls`'s business and nothing to do with these. Keeping
+ * them together also puts each limit beside the clipping plane derived from it — `maxPolarAngle`
+ * sizes the near plane, the maximum distance the far one.
+ *
+ * Configures R3F's camera rather than replacing it, which leaves `aspect` to R3F — it writes that on
+ * every resize, from the same size this reads. Mutations go through the store getter because the
+ * React Compiler refuses to lower a write to anything a hook returned.
+ * @param props - How far the plan may be zoomed and pitched, and what should reach the handle.
+ * @returns The children, under the camera handle.
+ */
+export function Camera(props) {
+    // Read one by one rather than destructured with defaults: the React Compiler cannot yet lower a
+    // default inside a destructuring statement.
+    const minZoom = props.minZoom ?? DEFAULT_MIN_ZOOM;
+    const maxZoom = props.maxZoom ?? DEFAULT_MAX_ZOOM;
+    const minPitch = props.minPitch ?? DEFAULT_MIN_PITCH;
+    const maxPitch = props.maxPitch ?? DEFAULT_MAX_PITCH;
+    const bounds = props.bounds;
+    const smoothTime = props.smoothTime;
+    const children = props.children;
+    const get = useThree((state) => state.get);
+    const invalidate = useThree((state) => state.invalidate);
+    // The camera is *identified* rather than held, so the effects below re-run when R3F swaps it out
+    // and reach the new one through `get()` — which they must, since the React Compiler refuses to
+    // lower a write to anything a hook returned. The controls are held, because every write to them
+    // here goes through a function that takes them as an argument, which is a line the compiler is
+    // happy with and this file is short enough to keep to.
+    const cameraId = useThree((state) => state.camera.uuid);
+    const controls = useCameraControls();
+    const space = useSpace();
+    const { width, height, dpr } = useCanvasSize();
+    const bufferHeight = height * dpr;
+    // The zoom the camera is held at, so a resize can dolly back to it. A ref rather than state:
+    // nothing renders from it, and the frame loop writes it.
+    const zoomFactorRef = useRef(1);
+    // Not memoized by hand: the React Compiler caches the call against `bufferHeight`, `controls` and
+    // `get`, which is its whole dependency list.
+    const handle = createCameraHandle(bufferHeight, () => cameraDistance(controls, get().camera));
+    // What the imperative renderer did when it built its camera and its controls.
+    useLayoutEffect(() => {
+        const state = get();
+        const camera = state.camera;
+        if (!isPerspective(camera))
+            return;
+        camera.fov = CAMERA_FOV;
+        // The plan's own up axis, so the camera sits upright over a plan authored y-down.
+        camera.up.set(0, 0, -1);
+        camera.updateProjectionMatrix();
+        // camera-controls builds its orbit space from the up axis when it is *constructed*, which is
+        // during the render that mounts it and so before this ever runs. Nothing else tells it the axis
+        // moved, and left stale it orbits the plan from the wrong side — where every face is turned away
+        // and the plan draws as an empty canvas.
+        controls?.updateCameraUp();
+    }, [cameraId, controls, get]);
+    // How long a programmatic move takes. Its own effect for the same reason the pitch limits have
+    // one: it shares no input with the framing, and folding it in would re-dolly the camera whenever
+    // a caller changed a duration.
+    useLayoutEffect(() => {
+        if (controls)
+            setSmoothTime(controls, smoothTime);
+    }, [controls, smoothTime]);
+    // The camera's boundary. A **passive** effect rather than a layout one, which is what makes it
+    // read the right fit: `Scene` refits the space in a layout effect, layout effects run
+    // child-before-parent, and this component is `Scene`'s child — so a layout effect here would
+    // convert the region through the fit it is in the middle of replacing. Every passive effect in
+    // the tree runs after every layout effect, which is exactly late enough.
+    //
+    // It re-runs on a resize because the boundary is stated in world units and the fit that produces
+    // them moves with the canvas. `bounds` is compared by identity, as any prop is: a caller changing
+    // the region hands over a new `Box` rather than editing the one it already gave.
+    useEffect(() => {
+        if (!controls)
+            return;
+        setCameraBounds(controls, bounds, space);
+        invalidate();
+    }, [bounds, controls, dpr, height, invalidate, space, width]);
+    // How far the plan may be pitched. Its own effect: nothing here shares an input with the framing
+    // below, so folding the two together would rewrite the frustum and re-dolly the camera every time
+    // a caller changed a pitch limit — and would tie the limits to the canvas having a size, which a
+    // plan that has not been laid out yet still does not need.
+    useLayoutEffect(() => {
+        if (controls)
+            setPitchLimits(controls, minPitch, maxPitch);
+    }, [controls, maxPitch, minPitch]);
+    // The framing: how far the camera may go, where that puts the far plane, and the dolly back to
+    // the zoom it was already at. What the imperative renderer did on every resize, in the same order
+    // and for the same reasons — `aspect` is the one step missing, because R3F writes it itself on
+    // each resize, from the same size this reads.
+    //
+    // These three are one effect because they are one transaction: the distance limits must be in
+    // place before the dolly, or it is clamped by the bounds of the previous buffer height, and the
+    // far plane is derived from the same `maxDistance` the limits are.
+    useLayoutEffect(() => {
+        const camera = get().camera;
+        if (!isPerspective(camera))
+            return;
+        // Skip transient 0-sized canvases, which would make a frustum full of NaNs.
+        const identity = zoomIdentityDistance(bufferHeight, CAMERA_FOV);
+        if (identity <= 0)
+            return;
+        // Preserve zoom across the resize: the factor was measured against the previous buffer height,
+        // and is turned back into a distance through the new one.
+        const distance = handle.zoomFactorToDistance(zoomFactorRef.current);
+        const maxDistance = identity / minZoom;
+        const minDistance = identity / maxZoom;
+        camera.far = farPlane(maxDistance);
+        camera.updateProjectionMatrix();
+        if (controls) {
+            setDistanceLimits(controls, minDistance, maxDistance);
+            void controls.dollyTo(distance, false);
+        }
+        else {
+            // Nothing to dolly before the controls mount, so the camera is placed straight away. The
+            // world matrix is refreshed with it: three re-derives it at render time, but `useFrame`
+            // callbacks run before that and `Lighting` reads `camera.matrixWorld` directly, so without
+            // this the key light spends a frame aimed from wherever the camera used to be — and under the
+            // demand frameloop, possibly no second frame comes to correct it.
+            camera.position.set(0, 0, -distance);
+            camera.updateMatrixWorld();
+        }
+        invalidate();
+    }, [bufferHeight, cameraId, controls, get, handle, invalidate, maxZoom, minZoom]);
+    useEffect(() => {
+        if (!isPerspective(get().camera))
+            return undefined;
+        if (!controls)
+            return undefined;
+        /**
+         * Learns the zoom from a move the controls have made, so a user dolly is what the next resize
+         * is held at.
+         *
+         * Only from their `update`, never from the distance they hold when this mounts. A controls
+         * instance is constructed during render, from whichever camera R3F had at the time — and R3F
+         * may swap that camera out from under a committed effect — so the distance before the fit above
+         * has run is not a framing anything chose. Seeding the zoom from it made the fit dolly to it,
+         * and the plan settled at the closest zoom its bounds allowed.
+         */
+        function trackZoom() {
+            zoomFactorRef.current = handle.distanceToZoomFactor(controls.distance);
+        }
+        controls.addEventListener('update', trackZoom);
+        return () => controls.removeEventListener('update', trackZoom);
+    }, [cameraId, controls, get, handle]);
+    // The near plane, synced on every rendered frame rather than from the controls' update event: the
+    // dolly is only one of its inputs. The other is `space.scale`, and a refit moves that without any
+    // camera event at all — the space is stable and this component never re-renders for it, so a
+    // by-the-frame read is what keeps the guarantee under either cause. Runs at the default priority,
+    // after the controls have updated at `-1`, so the frame about to draw is the one measured; on a
+    // still frame the recomputation lands on `camera.near` unchanged and writes nothing.
+    useFrame((state) => {
+        const camera = state.camera;
+        if (!isPerspective(camera))
+            return;
+        // No pitch is passed: `nearPlane` is sized against the hard cap, so this holds whatever the
+        // controls currently allow — including for a caller who mounted controls of their own and
+        // enforces nothing.
+        const near = nearPlane(cameraDistance(controls, state.camera), space.scale);
+        if (near === undefined || camera.near === near)
+            return;
+        camera.near = near;
+        camera.updateProjectionMatrix();
+    });
+    return _jsx(CameraContext, { value: handle, children: children });
+}
+/**
+ * Holds the camera's pitch inside the bounds, moving it there if it is already outside.
+ *
+ * The second clamp — of the camera, not of the limit — is what makes a tightened limit take effect
+ * on a plan already tilted past it, rather than only constraining the next gesture; which is what
+ * the imperative renderer's pitch handler did whenever its options changed.
+ * @param controls - The controls to constrain.
+ * @param minPitch - The shallowest pitch, in degrees.
+ * @param maxPitch - The steepest pitch, in degrees, itself capped at {@link MAX_PITCH}.
+ */
+function setPitchLimits(controls, minPitch, maxPitch) {
+    controls.minPolarAngle = degToRad(minPitch);
+    // Held to the hard cap however much more was asked for. Compared in degrees, which is the unit
+    // both are stated in, so the conversion happens once and after the clamp rather than either side
+    // of it.
+    controls.maxPolarAngle = degToRad(Math.min(maxPitch, MAX_PITCH));
+    if (controls.polarAngle < controls.minPolarAngle) {
+        void controls.rotatePolarTo(controls.minPolarAngle, false);
+    }
+    else if (controls.polarAngle > controls.maxPolarAngle) {
+        void controls.rotatePolarTo(controls.maxPolarAngle, false);
+    }
+}
+/**
+ * How far the camera is from the plan, which is what both the zoom factor and the near plane are
+ * read off.
+ *
+ * The controls own that distance once they mount. Before then — the frames between this component
+ * placing the camera and `Controls` publishing itself, and any scene rendered without controls at
+ * all — the camera has been put at `(0, 0, -distance)` looking straight down by the fit and nothing
+ * else has moved it, so its z offset *is* that distance. Not an approximation standing in for the
+ * real thing: the same number, still true by construction.
+ * @param controls - The scene's controls, when they have mounted.
+ * @param camera - The camera in use.
+ * @returns The distance in world units.
+ */
+function cameraDistance(controls, camera) {
+    return controls?.distance ?? Math.abs(camera.position.z);
+}
+/**
+ * Holds the camera's dolly between the two distances the zoom bounds work out to.
+ *
+ * A function taking the controls rather than two assignments in the effect, which is what lets the
+ * caller hold them from a hook: the React Compiler rejects a write to a *field of* a hook's return
+ * value, and is content once that value is an argument someone else was passed.
+ * @param controls - The controls to constrain.
+ * @param minDistance - The closest the camera may come to the plan, in world units.
+ * @param maxDistance - The furthest it may retreat.
+ */
+function setDistanceLimits(controls, minDistance, maxDistance) {
+    controls.minDistance = minDistance;
+    controls.maxDistance = maxDistance;
+}
+/**
+ * Holds the camera's target inside a region of the plan, or lets it go anywhere.
+ *
+ * The boundary camera-controls takes is in **world** units, and the plan-to-world fit changes on
+ * every resize, so the caller re-runs this whenever the canvas does.
+ * @param controls - The controls to constrain.
+ * @param bounds - The region, in plan units, or `undefined` to remove the boundary.
+ * @param space - The scene's space, which converts the region into world units.
+ */
+function setCameraBounds(controls, bounds, space) {
+    if (!bounds) {
+        controls.setBoundary(undefined);
+        return;
+    }
+    // Two corners are the whole box: the plan-to-world mapping scales and translates, so opposite
+    // corners stay opposite.
+    const min = space.planToWorld({ ...bounds.min, z: 0 }, _min);
+    const max = space.planToWorld({ ...bounds.max, z: 0 }, _max);
+    controls.setBoundary(_boundary.set(min, max));
+}
+/**
+ * How long the controls take to settle a programmatic move.
+ *
+ * **Every duration is written on every call**, so the prop says the whole truth rather than
+ * accumulating: naming one sets it, and *not* naming one returns it to the default. Going from
+ * `{ zoomTime: 0.5 }` to `{ panTime: 2 }` therefore means "pan takes two seconds and zoom goes back
+ * to normal" — a caller who wanted both would have named both. That is what a prop should mean, and
+ * it is not what the library's own setter does: handed an object it *merges*, writing the durations
+ * named and leaving the rest at whatever they last were.
+ *
+ * The four names a caller uses map onto the four the library drives; `zoom` and `offset` are left
+ * alone, since nothing in this renderer moves them.
+ *
+ * A function taking the controls for the same reason {@link setPitchLimits} is one: the React
+ * Compiler rejects a write to a field of a hook's return value and is content once that value is an
+ * argument someone else was passed.
+ * @param controls - The controls to configure.
+ * @param smoothTime - The durations a caller asked for, if any.
+ */
+function setSmoothTime(controls, smoothTime) {
+    controls.smoothTime = {
+        dolly: smoothTime?.zoomTime ?? DEFAULT_SMOOTH_TIME,
+        truck: smoothTime?.panTime ?? DEFAULT_SMOOTH_TIME,
+        rotateAzimuth: smoothTime?.rollTime ?? DEFAULT_SMOOTH_TIME,
+        rotatePolar: smoothTime?.pitchTime ?? DEFAULT_SMOOTH_TIME,
+    };
+}
+/** How far out the plan may be pushed when a caller names no limit: a tenth of the framing that fits it. */
+const DEFAULT_MIN_ZOOM = 0.1;
+/** How far in the plan may be brought when a caller names no limit. */
+const DEFAULT_MAX_ZOOM = 35;
+/** How far the plan may be pitched toward face-on when a caller names no limit: all the way. */
+const DEFAULT_MIN_PITCH = 0;
+/**
+ * How far the plan may be pitched away from face-on when a caller names no limit: as far as it is
+ * allowed to go.
+ *
+ * Written as its own constant rather than used directly, because the two answer different questions
+ * — "what do you get if you say nothing" and "what may you not exceed" — and only happen to agree.
+ * Lowering the default would be a judgement about how plans look; lowering the cap would be a
+ * judgement about what the depth buffer can resolve.
+ */
+const DEFAULT_MAX_PITCH = MAX_PITCH;
+/**
+ * How long a programmatic move takes to settle when a caller names no duration, in seconds.
+ *
+ * `camera-controls`' own default, restated because {@link setSmoothTime} writes every duration on
+ * every call rather than merging — see there for why.
+ */
+const DEFAULT_SMOOTH_TIME = 0.25;
+const _boundary = new Box3();
+const _min = new Vector3();
+const _max = new Vector3();

package/dist/space/Scene.d.ts

@@ -0,0 +1,44 @@
+import { type Box } from '@expofp/geometry';
+import { type ReactNode } from 'react';
+import { type SceneDef } from '../types/defs';
+import { type CameraProps } from './Camera';
+/** Props for {@link Scene}: the scene to draw, plus the camera limits it passes straight down. */
+export interface SceneProps extends CameraProps {
+    /** The scene definition to render. */
+    sceneDef: SceneDef;
+    /**
+     * Soft cap, in megabytes, on the GPU memory the image atlases may consume; see
+     * {@link RendererProps.memoryLimit}.
+     */
+    memoryLimit?: number;
+    /**
+     * The part of the canvas the plan should be framed inside; see {@link RendererProps.visibleRect}.
+     */
+    visibleRect?: Box;
+    /**
+     * Whether an external host owns the camera. When set, the scene mounts no {@link Camera} — and
+     * with it no fit, no `visibleRect` framing and no camera commands: the view arrives from the
+     * host, one matrix per frame, written by the external mount. The space and the graph are the
+     * same either way.
+     */
+    external?: boolean;
+    /**
+     * Components that need the scene's space, camera and re-layout registry — the renderer's own
+     * controls and missed-click bridge, and anything a caller renders inside `<Renderer>`.
+     */
+    children?: ReactNode;
+}
+/**
+ * A floor-plan scene: the plan's own space, the camera that frames it, and the layer tree drawn
+ * through both.
+ *
+ * Composed from two halves — {@link PlanSpace}, which owns the {@link Space}, and
+ * {@link SceneGraph}, which keeps it fitted and draws the layer tree under the re-layout
+ * registry. Between them sits the renderer's own {@link Camera}: the one part `external` leaves
+ * unmounted, since there the host owns the camera and the fit alike and the external mount writes
+ * the view straight onto its own bare camera.
+ * @param props - The scene to render, and what should reach its space.
+ * @returns The scene.
+ */
+export declare function Scene(props: SceneProps): import("react").JSX.Element;
+//# sourceMappingURL=Scene.d.ts.map

package/dist/space/Scene.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useThree } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { LayoutDriver } from '../events/LayoutDriver';
+import { Background } from '../objects/Background';
+import { TextureBudget, TextureBudgetContext } from '../objects/images/texture-budget';
+import { Layer } from '../objects/layer/index';
+import { createMountScheduler, MountSchedulerContext } from '../objects/layer/mount-scheduler';
+import { Lighting } from '../objects/Lighting';
+import { createLogger, printScene } from '../utils/logging';
+import { Camera } from './Camera';
+import { useCanvasSize } from './canvas-size';
+import { Space, SpaceContext, useSpace } from './Space';
+import { VisibleRect } from './VisibleRect';
+const logger = createLogger('scene');
+/**
+ * A floor-plan scene: the plan's own space, the camera that frames it, and the layer tree drawn
+ * through both.
+ *
+ * Composed from two halves — {@link PlanSpace}, which owns the {@link Space}, and
+ * {@link SceneGraph}, which keeps it fitted and draws the layer tree under the re-layout
+ * registry. Between them sits the renderer's own {@link Camera}: the one part `external` leaves
+ * unmounted, since there the host owns the camera and the fit alike and the external mount writes
+ * the view straight onto its own bare camera.
+ * @param props - The scene to render, and what should reach its space.
+ * @returns The scene.
+ */
+export function Scene(props) {
+    const { sceneDef, memoryLimit, visibleRect, external, children, ...cameraProps } = props;
+    const { viewbox, staticTransform } = sceneDef;
+    useEffect(() => {
+        if (visibleRect && staticTransform) {
+            logger.warn('visibleRect is ignored for a scene with a staticTransform');
+        }
+    }, [visibleRect, staticTransform]);
+    const graph = (_jsx(SceneGraph, { sceneDef: sceneDef, memoryLimit: memoryLimit, children: children }));
+    return (_jsx(PlanSpace, { sceneDef: sceneDef, children: external ? (graph) : (_jsxs(Camera, { ...cameraProps, children: [visibleRect && !staticTransform && _jsx(VisibleRect, { rect: visibleRect, viewbox: viewbox }), graph] })) }));
+}
+/**
+ * Owns the plan's {@link Space} and publishes it above everything else.
+ *
+ * This is the one mount point the rest hangs from, which is what lets the pieces reach each other
+ * without a provider apiece — a component that converts coordinates or measures the plan does not
+ * have to be inside the layer tree to do it. One space for the scene's lifetime is the point: its
+ * consumers read the current fit through a stable identity, so a resize re-renders none of them —
+ * see the contract on {@link Space}. Created already fitted rather than refit into shape by
+ * {@link SceneGraph}'s effect, so anything that measures the plan while mounting — the layout
+ * driver seeding its pixel size, defs laying out before the first frame — reads the real fit, not
+ * a placeholder.
+ * @param props - The scene whose space to own, and everything mounted under it.
+ * @returns The children, under the space.
+ */
+function PlanSpace(props) {
+    const { sceneDef, children } = props;
+    const { viewbox, staticTransform } = sceneDef;
+    const { width, height, dpr } = useCanvasSize();
+    const [space] = useState(() => new Space({ viewbox, width, height, dpr, staticTransform }));
+    return _jsx(SpaceContext, { value: space, children: children });
+}
+/**
+ * The layer tree drawn through the scene's space, under the re-layout registry — and the keeper of
+ * the fit, which it re-applies whenever the canvas resizes.
+ *
+ * The refit is a layout effect rather than render work, because the mutation must land exactly once
+ * per commit — a render the concurrent renderer discards would otherwise move a fit no commit asked
+ * for. It runs before an enclosing {@link Camera}'s own layout effects (child before parent), and
+ * that is fine for the same reason the original ordering was: nothing reads the fit during commit —
+ * the camera's near plane, the one consumer that would care, syncs from the frame loop.
+ *
+ * The matrix goes onto a group with `matrixAutoUpdate` off, rather than decomposed into
+ * `position`/`scale` props, because a `staticTransform` may be any affine matrix and there is no
+ * decomposition worth the round trip. The mirrored z the fit carries is documented on
+ * {@link Space}: a def authored at elevation 10 lands nearer the camera, and floorplan never learns
+ * about the axis mapping. Three already handles the negative determinant — it flips `gl.frontFace`
+ * for a mirrored world matrix and carries normals through the normal matrix — so culling and
+ * lighting need no compensation.
+ * @param props - The scene to draw and what rides along inside the registry.
+ * @returns The graph.
+ */
+function SceneGraph(props) {
+    const { sceneDef, memoryLimit, children } = props;
+    const { viewbox, staticTransform, rootLayer } = sceneDef;
+    const { width, height, dpr } = useCanvasSize();
+    const invalidate = useThree((state) => state.invalidate);
+    const space = useSpace();
+    const [scheduler] = useState(createMountScheduler);
+    // One budget for the scene's lifetime; the limit is synced rather than the budget rebuilt, so an
+    // atlas's registration survives a `memoryLimit` change.
+    const [budget] = useState(() => new TextureBudget(memoryLimit));
+    const worldRef = useRef(null);
+    useLayoutEffect(() => {
+        space.refit({ viewbox, width, height, dpr, staticTransform });
+        // Written by hand because the refit mutates in place: the group was given the matrix once at
+        // mount, and R3F re-applies a `matrix` prop only when its identity changes. The dirty flag makes
+        // three recompose the subtree's world matrices on the next pass, and the invalidate asks for it.
+        const world = worldRef.current;
+        if (world) {
+            world.matrix.copy(space.matrix);
+            world.matrixWorldNeedsUpdate = true;
+        }
+        invalidate();
+    }, [space, viewbox, width, height, dpr, staticTransform, invalidate]);
+    useEffect(() => {
+        budget.setMemoryLimit(memoryLimit);
+        if (!memoryLimit)
+            logger.debug('no memory limit set, image atlases upload at full size');
+    }, [budget, memoryLimit]);
+    useEffect(() => {
+        printScene(sceneDef, logger.debug);
+    }, [sceneDef]);
+    return (_jsxs(LayoutDriver, { children: [_jsxs("group", { name: "world", ref: worldRef, matrixAutoUpdate: false, matrix: space.matrix, children: [_jsx(Lighting, {}), _jsx(TextureBudgetContext, { value: budget, children: _jsx(MountSchedulerContext, { value: scheduler, children: _jsx(Layer, { layer: rootLayer, children: sceneDef.background !== undefined && _jsx(Background, { color: sceneDef.background }) }) }) })] }), children] }));
+}