@jgengine/shell 0.6.0 → 0.8.0

package/dist/audio/AudioComponents.d.ts

@@ -0,0 +1,12 @@
+import type { AudioEngine } from "./audioEngine.js";
+export declare function AudioListener({ engine }: {
+    engine: AudioEngine;
+}): null;
+export declare function EntityAudioEmitters({ engine, entitySounds, }: {
+    engine: AudioEngine;
+    entitySounds: Record<string, string> | undefined;
+}): null;
+export declare function ObjectAudioEmitters({ engine, objectSounds, }: {
+    engine: AudioEngine;
+    objectSounds: Record<string, string> | undefined;
+}): null;

package/dist/audio/AudioComponents.js

@@ -0,0 +1,53 @@
+import { useFrame, useThree } from "@react-three/fiber";
+import { useEffect, useRef } from "react";
+import { useSceneEntities, useSceneObjects } from "@jgengine/react/hooks";
+export function AudioListener({ engine }) {
+    const camera = useThree((state) => state.camera);
+    useFrame(() => {
+        engine.setListenerPose({ x: camera.position.x, y: camera.position.y, z: camera.position.z });
+    });
+    return null;
+}
+function useTrackedEmitters(engine, soundByKey, entries) {
+    const handles = useRef(new Map());
+    useEffect(() => () => {
+        for (const handle of handles.current.values())
+            handle.stop();
+        handles.current.clear();
+    }, [engine]);
+    useFrame(() => {
+        if (soundByKey === undefined)
+            return;
+        const live = new Set();
+        for (const entry of entries) {
+            const soundId = soundByKey[entry.key];
+            if (soundId === undefined)
+                continue;
+            live.add(entry.id);
+            let handle = handles.current.get(entry.id);
+            if (handle === undefined) {
+                handle = engine.playLoop(soundId, { x: entry.position[0], y: entry.position[1], z: entry.position[2] }) ?? undefined;
+                if (handle !== undefined)
+                    handles.current.set(entry.id, handle);
+                continue;
+            }
+            handle.setPosition({ x: entry.position[0], y: entry.position[1], z: entry.position[2] });
+        }
+        for (const [id, handle] of handles.current) {
+            if (!live.has(id)) {
+                handle.stop();
+                handles.current.delete(id);
+            }
+        }
+    });
+}
+export function EntityAudioEmitters({ engine, entitySounds, }) {
+    const entities = useSceneEntities();
+    useTrackedEmitters(engine, entitySounds, entities.map((entity) => ({ id: entity.id, key: entity.name, position: entity.position })));
+    return null;
+}
+export function ObjectAudioEmitters({ engine, objectSounds, }) {
+    const objects = useSceneObjects();
+    useTrackedEmitters(engine, objectSounds, objects.map((object) => ({ id: object.instanceId, key: object.catalogId, position: object.position })));
+    return null;
+}

package/dist/audio/audioEngine.d.ts

@@ -0,0 +1,23 @@
+import { type AudioBusDef, type SoundDef } from "@jgengine/core/audio/audioFalloff";
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface AudioSceneConfig {
+    sounds?: Record<string, SoundDef>;
+    buses?: Record<string, AudioBusDef>;
+}
+export interface AudioEmitterHandle {
+    setPosition(position: Vec3): void;
+    stop(): void;
+}
+export interface AudioEngine {
+    setListenerPose(position: Vec3): void;
+    playOneShot(soundId: string, position?: Vec3): void;
+    playLoop(soundId: string, position?: Vec3): AudioEmitterHandle | null;
+    setBusGain(busId: string, gain: number): void;
+    resume(): void;
+    dispose(): void;
+}
+export declare function createAudioEngine(config?: AudioSceneConfig): AudioEngine;

package/dist/audio/audioEngine.js

@@ -0,0 +1,110 @@
+import { distance3, resolveEmitterGain } from "@jgengine/core/audio/audioFalloff";
+function createNoopEngine() {
+    return {
+        setListenerPose: () => undefined,
+        playOneShot: () => undefined,
+        playLoop: () => null,
+        setBusGain: () => undefined,
+        resume: () => undefined,
+        dispose: () => undefined,
+    };
+}
+function resolveAudioContextCtor() {
+    if (typeof window === "undefined")
+        return undefined;
+    return (window.AudioContext ??
+        window.webkitAudioContext);
+}
+export function createAudioEngine(config = {}) {
+    const sounds = config.sounds ?? {};
+    const busDefs = config.buses ?? {};
+    const AudioContextCtor = resolveAudioContextCtor();
+    if (AudioContextCtor === undefined)
+        return createNoopEngine();
+    let context;
+    let masterGain;
+    try {
+        context = new AudioContextCtor();
+        masterGain = context.createGain();
+        masterGain.connect(context.destination);
+    }
+    catch {
+        return createNoopEngine();
+    }
+    const busGains = new Map();
+    function busGainNode(busId) {
+        let node = busGains.get(busId);
+        if (node === undefined) {
+            node = context.createGain();
+            node.gain.value = busDefs[busId]?.gain ?? 1;
+            node.connect(masterGain);
+            busGains.set(busId, node);
+        }
+        return node;
+    }
+    const bufferCache = new Map();
+    function loadBuffer(url) {
+        let pending = bufferCache.get(url);
+        if (pending === undefined) {
+            pending = fetch(url)
+                .then((response) => response.arrayBuffer())
+                .then((data) => context.decodeAudioData(data))
+                .catch(() => null);
+            bufferCache.set(url, pending);
+        }
+        return pending;
+    }
+    let listenerPosition = { x: 0, y: 0, z: 0 };
+    function playInternal(soundId, position, loop) {
+        const sound = sounds[soundId];
+        if (sound === undefined)
+            return null;
+        const bus = busGainNode(sound.bus);
+        let currentPosition = position ?? listenerPosition;
+        let gainNode = null;
+        let stopped = false;
+        void loadBuffer(sound.url).then((buffer) => {
+            if (stopped || buffer === null)
+                return;
+            const sourceNode = context.createBufferSource();
+            sourceNode.buffer = buffer;
+            sourceNode.loop = loop || (sound.loop ?? false);
+            gainNode = context.createGain();
+            gainNode.gain.value = resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1);
+            sourceNode.connect(gainNode);
+            gainNode.connect(bus);
+            sourceNode.start();
+        });
+        return {
+            setPosition(next) {
+                currentPosition = next;
+                if (gainNode !== null) {
+                    gainNode.gain.value = resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1);
+                }
+            },
+            stop() {
+                stopped = true;
+            },
+        };
+    }
+    return {
+        setListenerPose(position) {
+            listenerPosition = position;
+        },
+        playOneShot(soundId, position) {
+            playInternal(soundId, position, false);
+        },
+        playLoop(soundId, position) {
+            return playInternal(soundId, position, true);
+        },
+        setBusGain(busId, gain) {
+            busGainNode(busId).gain.value = gain;
+        },
+        resume() {
+            void context.resume().catch(() => undefined);
+        },
+        dispose() {
+            void context.close().catch(() => undefined);
+        },
+    };
+}

package/dist/behaviour.d.ts

@@ -0,0 +1,31 @@
+import type { Object3D } from "three";
+import { Behaviour, type BehaviourWorld } from "@jgengine/core/behaviour/behaviour";
+/**
+ * A core `Behaviour` bound to a three.js object. `onBeforeRender`/`onAfterRender`
+ * ride the object's own three.js render callbacks, so they only fire for renderable
+ * objects (Mesh, Line, Points, Sprite) that are visible and in frustum — attach to
+ * the mesh itself, not a parent Group, when you need them.
+ */
+export declare class Object3DBehaviour extends Behaviour {
+    /** @internal */ _object: Object3D | null;
+    /** The bound three.js object; available from `onAwake` onward. */
+    get object(): Object3D;
+    onBeforeRender(): void;
+    onAfterRender(): void;
+}
+/**
+ * Binds `behaviour` to `object` and attaches it to `world` under `nodeId`
+ * (default: the object's uuid). Render hooks are chained onto the object's
+ * existing `onBeforeRender`/`onAfterRender` only when actually overridden, and
+ * are gated on the behaviour being active; the update lifecycle still flows
+ * through `world.update`.
+ */
+export declare function attachObject3D<T extends Object3DBehaviour>(world: BehaviourWorld, object: Object3D, behaviour: T, nodeId?: string): T;
+/**
+ * Bootstraps `world` on mount and dispatches `world.update` every frame at
+ * simulation priority. `scaleDt` maps the raw frame delta to the dt behaviours
+ * receive — pass the game clock's scaling to keep behaviours on game time, or
+ * omit for real-time seconds. Games driving `world.update` themselves from
+ * `loop.onTick` should not also render this.
+ */
+export declare function useBehaviourWorld(world: BehaviourWorld, scaleDt?: (rawDt: number) => number): void;

package/dist/behaviour.js

@@ -0,0 +1,63 @@
+import { useFrame } from "@react-three/fiber";
+import { useEffect } from "react";
+import { Behaviour } from "@jgengine/core/behaviour/behaviour";
+/**
+ * A core `Behaviour` bound to a three.js object. `onBeforeRender`/`onAfterRender`
+ * ride the object's own three.js render callbacks, so they only fire for renderable
+ * objects (Mesh, Line, Points, Sprite) that are visible and in frustum — attach to
+ * the mesh itself, not a parent Group, when you need them.
+ */
+export class Object3DBehaviour extends Behaviour {
+    /** @internal */ _object = null;
+    /** The bound three.js object; available from `onAwake` onward. */
+    get object() {
+        if (this._object === null)
+            throw new Error("behaviour is not bound to an Object3D");
+        return this._object;
+    }
+    onBeforeRender() { }
+    onAfterRender() { }
+}
+/**
+ * Binds `behaviour` to `object` and attaches it to `world` under `nodeId`
+ * (default: the object's uuid). Render hooks are chained onto the object's
+ * existing `onBeforeRender`/`onAfterRender` only when actually overridden, and
+ * are gated on the behaviour being active; the update lifecycle still flows
+ * through `world.update`.
+ */
+export function attachObject3D(world, object, behaviour, nodeId = object.uuid) {
+    behaviour._object = object;
+    world.attach(nodeId, behaviour);
+    if (behaviour.onBeforeRender !== Object3DBehaviour.prototype.onBeforeRender) {
+        const previous = object.onBeforeRender;
+        object.onBeforeRender = function chainedBeforeRender(...args) {
+            previous.apply(this, args);
+            if (behaviour.isActive)
+                behaviour.onBeforeRender();
+        };
+    }
+    if (behaviour.onAfterRender !== Object3DBehaviour.prototype.onAfterRender) {
+        const previous = object.onAfterRender;
+        object.onAfterRender = function chainedAfterRender(...args) {
+            previous.apply(this, args);
+            if (behaviour.isActive)
+                behaviour.onAfterRender();
+        };
+    }
+    return behaviour;
+}
+/**
+ * Bootstraps `world` on mount and dispatches `world.update` every frame at
+ * simulation priority. `scaleDt` maps the raw frame delta to the dt behaviours
+ * receive — pass the game clock's scaling to keep behaviours on game time, or
+ * omit for real-time seconds. Games driving `world.update` themselves from
+ * `loop.onTick` should not also render this.
+ */
+export function useBehaviourWorld(world, scaleDt) {
+    useEffect(() => {
+        world.start();
+    }, [world]);
+    useFrame((_state, rawDt) => {
+        world.update(scaleDt === undefined ? rawDt : scaleDt(rawDt));
+    });
+}

package/dist/camera/GameCameraRig.d.ts

@@ -0,0 +1,16 @@
+import { type MutableRefObject } from "react";
+import type { GameCameraConfig } from "@jgengine/core/game/playableGame";
+import type { CameraDirector } from "@jgengine/core/runtime/cameraDirector";
+export { resolveRigKind } from "./rigResolve.js";
+export interface GameCameraRigProps {
+    yawRef: MutableRefObject<number>;
+    pitchRef: MutableRefObject<number>;
+    config?: GameCameraConfig;
+    onDragChange?: (dragging: boolean) => void;
+    pointerControls?: boolean;
+    /** False when the game's own input map already claims WASD, so the RTS rig should stop panning on those keys. */
+    panKeysEnabled?: boolean;
+    /** Runtime follow/cinematic override (#196.2). While present it wins over the static `config` for any field it reports non-`undefined`/non-`null`; absent (or an all-`undefined` snapshot) is a no-op. */
+    director?: CameraDirector;
+}
+export declare function GameCameraRig({ yawRef, pitchRef, config, onDragChange, pointerControls, panKeysEnabled, director, }: GameCameraRigProps): import("react").JSX.Element;

package/dist/camera/GameCameraRig.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useReducer } from "react";
+import { ChaseRig, CinematicRig, LockOnRig, ObserverRig, RtsRig, ShoulderRig, SideScrollRig, TopDownRig, } from "./cameraRigs.js";
+import { GameFirstPersonCamera } from "./GameFirstPersonCamera.js";
+import { GameInspectionCamera } from "./GameInspectionCamera.js";
+import { GameOrbitCamera } from "./GameOrbitCamera.js";
+import { resolveDirectedCamera } from "./rigMath.js";
+import { resolveRigKind, turntableAsObserver } from "./rigResolve.js";
+import { CameraShakeContext, createCameraShakeChannel } from "./shakeChannel.js";
+export { resolveRigKind } from "./rigResolve.js";
+export function GameCameraRig({ yawRef, pitchRef, config, onDragChange, pointerControls, panKeysEnabled, director, }) {
+    const channel = useMemo(() => createCameraShakeChannel(config?.shake?.decayPerSecond), [config?.shake?.decayPerSecond]);
+    const [, notifyDirectorChange] = useReducer((count) => count + 1, 0);
+    useEffect(() => {
+        if (director === undefined)
+            return undefined;
+        return director.subscribe(notifyDirectorChange);
+    }, [director]);
+    const directed = resolveDirectedCamera(director === undefined
+        ? undefined
+        : { followEntityId: director.followedEntityId(), cinematic: director.cinematic() }, { followEntityId: config?.followEntityId, cinematic: config?.cinematic });
+    const followEntityId = directed.followEntityId;
+    const rig = (() => {
+        if (directed.cinematic !== undefined) {
+            return (_jsx(CinematicRig, { yawRef: yawRef, pitchRef: pitchRef, config: { ...config, cinematic: directed.cinematic }, followEntityId: followEntityId }));
+        }
+        const kind = resolveRigKind(config);
+        switch (kind) {
+            case "first":
+                return (_jsx(GameFirstPersonCamera, { yawRef: yawRef, pitchRef: pitchRef, config: config?.firstPerson, followEntityId: followEntityId ?? undefined }));
+            case "topDown":
+                return _jsx(TopDownRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "rts":
+                return (_jsx(RtsRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId, panKeysEnabled: panKeysEnabled }));
+            case "shoulder":
+                return _jsx(ShoulderRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "lockOn":
+                return _jsx(LockOnRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "chase":
+                return _jsx(ChaseRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "observer":
+                return _jsx(ObserverRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "turntable":
+                return (_jsx(ObserverRig, { yawRef: yawRef, pitchRef: pitchRef, config: turntableAsObserver(config), followEntityId: followEntityId }));
+            case "sideScroll":
+                return _jsx(SideScrollRig, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId });
+            case "inspection":
+                return _jsx(GameInspectionCamera, { config: config?.inspection });
+            case "none":
+                return null;
+            default:
+                return (_jsx(GameOrbitCamera, { yawRef: yawRef, pitchRef: pitchRef, config: config, followEntityId: followEntityId ?? undefined, onCameraFollow: config?.onCameraFollow, onDragChange: onDragChange, pointerControls: pointerControls }));
+        }
+    })();
+    return _jsx(CameraShakeContext.Provider, { value: channel, children: rig });
+}

package/dist/camera/GameFirstPersonCamera.js

@@ -19,6 +19,8 @@ export function GameFirstPersonCamera({ yawRef, pitchRef, config, followEntityId
     const followId = followEntityId ?? userId;
     useEffect(() => {
         const requestLock = () => {
+            if (window.matchMedia?.("(pointer: coarse)").matches)
+                return;
             if (document.pointerLockElement !== domElement)
                 void domElement.requestPointerLock?.();
         };

package/dist/camera/GameInspectionCamera.d.ts

@@ -0,0 +1,6 @@
+import { type InspectionCameraConfig } from "./inspectionCameraMath.js";
+export interface GameInspectionCameraProps {
+    config?: InspectionCameraConfig;
+}
+/** Model-viewer style rig (#207.7): left-drag orbit, middle/right-drag pan, scroll zoom toward a configurable anchor. Orbits a fixed `target`; never reads player/entity state. */
+export declare function GameInspectionCamera({ config: configPatch }: GameInspectionCameraProps): import("react").JSX.Element;

package/dist/camera/GameInspectionCamera.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { OrbitControls } from "@react-three/drei";
+import { useThree } from "@react-three/fiber";
+import { useEffect, useRef } from "react";
+import { MOUSE } from "three";
+import { resolveInspectionCameraConfig, resolveInspectionZoomToCursor, seedInspectionCamera, } from "./inspectionCameraMath.js";
+/** Model-viewer style rig (#207.7): left-drag orbit, middle/right-drag pan, scroll zoom toward a configurable anchor. Orbits a fixed `target`; never reads player/entity state. */
+export function GameInspectionCamera({ config: configPatch }) {
+    const config = resolveInspectionCameraConfig(configPatch);
+    const controlsRef = useRef(null);
+    const camera = useThree((state) => state.camera);
+    const seededRef = useRef(false);
+    useEffect(() => {
+        if (seededRef.current)
+            return;
+        const seeded = seedInspectionCamera(config);
+        camera.position.set(seeded.camera.x, seeded.camera.y, seeded.camera.z);
+        camera.lookAt(seeded.target.x, seeded.target.y, seeded.target.z);
+        controlsRef.current?.target.set(seeded.target.x, seeded.target.y, seeded.target.z);
+        controlsRef.current?.update();
+        seededRef.current = true;
+    }, [camera, config]);
+    return (_jsx(OrbitControls, { ref: controlsRef, enableDamping: true, dampingFactor: config.dampingFactor, rotateSpeed: config.rotateSpeed, zoomSpeed: config.zoomSpeed, zoomToCursor: resolveInspectionZoomToCursor(config.anchor), enablePan: config.pan, enableRotate: true, enableZoom: true, minDistance: config.minDistance, maxDistance: config.maxDistance, minPolarAngle: config.minPolarAngle, maxPolarAngle: config.maxPolarAngle, screenSpacePanning: true, mouseButtons: { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.PAN, RIGHT: MOUSE.PAN } }));
+}

package/dist/camera/GameOrbitCamera.d.ts

@@ -13,7 +13,9 @@ export interface GameOrbitCameraProps {
     resolveFollowTarget?: (entity: SceneEntity) => Vec3;
     onDragChange?: (dragging: boolean) => void;
     onCameraFollow?: CameraFollowListener;
+    /** Free the left mouse button for pointer verbs (marquee / click-to-move); orbit moves to the middle button. */
+    pointerControls?: boolean;
 }
-export declare function GameOrbitCamera({ yawRef, pitchRef, config: configPatch, followEntityId, resolveFollowTarget, onDragChange, onCameraFollow, }: GameOrbitCameraProps): import("react").JSX.Element;
+export declare function GameOrbitCamera({ yawRef, pitchRef, config: configPatch, followEntityId, resolveFollowTarget, onDragChange, onCameraFollow, pointerControls, }: GameOrbitCameraProps): import("react").JSX.Element;
 /** Seed orbit target before controls mount (demo spawn at origin). */
 export declare function seedOrbitCameraTarget(camera: Camera, target: Vector3, distance: number, height: number): void;

package/dist/camera/GameOrbitCamera.js

@@ -6,7 +6,7 @@ import { MOUSE, Vector3 } from "three";
 import { useGameContext } from "@jgengine/react/provider";
 import { usePlayer } from "@jgengine/react/hooks";
 import { cameraLookPitch, ORBIT_CAMERA_FRAME_PRIORITY, orbitFollowStep, orbitYawFromCamera, resolveFollowTargetFromPosition, resolveOrbitCameraConfig, seedOrbitFollowState, } from "./orbitCameraMath.js";
-export function GameOrbitCamera({ yawRef, pitchRef, config: configPatch, followEntityId, resolveFollowTarget, onDragChange, onCameraFollow, }) {
+export function GameOrbitCamera({ yawRef, pitchRef, config: configPatch, followEntityId, resolveFollowTarget, onDragChange, onCameraFollow, pointerControls = false, }) {
     const config = resolveOrbitCameraConfig(configPatch);
     const controlsRef = useRef(null);
     const runtimeRef = useRef(null);
@@ -71,7 +71,9 @@ export function GameOrbitCamera({ yawRef, pitchRef, config: configPatch, followE
             distance: runtimeRef.current.lockedDistance ?? stepped.distance,
         });
     }, ORBIT_CAMERA_FRAME_PRIORITY);
-    return (_jsx(OrbitControls, { ref: controlsRef, enableDamping: true, dampingFactor: config.dampingFactor, rotateSpeed: config.rotateSpeed, zoomSpeed: config.zoomSpeed, enablePan: false, enableRotate: true, enableZoom: true, minDistance: config.minDistance, maxDistance: config.maxDistance, maxPolarAngle: config.maxPolarAngle, minPolarAngle: config.minPolarAngle, screenSpacePanning: false, mouseButtons: { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: undefined }, onStart: () => {
+    return (_jsx(OrbitControls, { ref: controlsRef, enableDamping: true, dampingFactor: config.dampingFactor, rotateSpeed: config.rotateSpeed, zoomSpeed: config.zoomSpeed, enablePan: false, enableRotate: true, enableZoom: true, minDistance: config.minDistance, maxDistance: config.maxDistance, maxPolarAngle: config.maxPolarAngle, minPolarAngle: config.minPolarAngle, screenSpacePanning: false, mouseButtons: pointerControls
+            ? { LEFT: undefined, MIDDLE: MOUSE.ROTATE, RIGHT: undefined }
+            : { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: undefined }, onStart: () => {
             draggingRef.current = true;
             onDragChange?.(true);
         }, onEnd: () => {

package/dist/camera/cameraRigs.d.ts

@@ -0,0 +1,26 @@
+import { type MutableRefObject } from "react";
+import type { GameCameraConfig } from "@jgengine/core/game/playableGame";
+export declare const CAMERA_RIG_FRAME_PRIORITY = -1;
+export declare const CAMERA_POST_FRAME_PRIORITY: number;
+export interface RigProps {
+    yawRef: MutableRefObject<number>;
+    pitchRef: MutableRefObject<number>;
+    config?: GameCameraConfig;
+    followEntityId?: string | null;
+}
+export declare function TopDownRig(props: RigProps): null;
+/** Fixed side-on 2.5D follow rig: watches the followed entity from the perpendicular axis, never reading WASD/mouse-look. */
+export declare function SideScrollRig(props: RigProps): null;
+export declare function RtsRig(props: RigProps & {
+    panKeysEnabled?: boolean;
+}): null;
+export declare function ShoulderRig(props: RigProps): null;
+export declare function LockOnRig(props: RigProps): null;
+export declare function ChaseRig(props: RigProps): null;
+/**
+ * Detached spectator/photo cam (#120): binds to any entity or fixed point and
+ * auto-orbits it, reading no player input at all — the van CCTV / photo-mode /
+ * kill-cam rig. Distinct from every other rig, which drives from mouse/keys.
+ */
+export declare function ObserverRig(props: RigProps): null;
+export declare function CinematicRig(props: RigProps): null;