@plasius/renderer 1.0.0

package/dist/camera/managedCameraController.js

@@ -0,0 +1,271 @@
+import { useEffect, useRef } from "react";
+import { useFrame, useThree } from "@react-three/fiber";
+import { createCameraManager, } from "@plasius/gpu-camera";
+import { Vector3 } from "three";
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function length3(value) {
+    return Math.hypot(value[0], value[1], value[2]);
+}
+function normalize3(value, fallback) {
+    const len = length3(value);
+    if (len <= Number.EPSILON) {
+        return [...fallback];
+    }
+    return [value[0] / len, value[1] / len, value[2] / len];
+}
+function sub3(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add3(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale3(value, scalar) {
+    return [value[0] * scalar, value[1] * scalar, value[2] * scalar];
+}
+function cross3(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    ];
+}
+export function resolveCameraAspect(width, height) {
+    if (!Number.isFinite(width) || !Number.isFinite(height) || height <= 0) {
+        return 1;
+    }
+    return Math.max(1 / 4096, width / height);
+}
+export function createRendererCameraManager(options) {
+    return createCameraManager({
+        maxParallelViews: options?.maxParallelViews ?? 2,
+        maxHotCameras: options?.maxHotCameras ?? 3,
+    });
+}
+export function derivePanDeltaFromCameraState(cameraState, deltaX, deltaY, panSpeed) {
+    const position = cameraState.transform.position;
+    const target = cameraState.transform.target;
+    const up = normalize3(cameraState.transform.up ?? [0, 1, 0], [0, 1, 0]);
+    const forward = normalize3(sub3(target, position), [0, 0, -1]);
+    const right = normalize3(cross3(forward, up), [1, 0, 0]);
+    const radius = Math.max(0.01, length3(sub3(position, target)));
+    const scale = Math.max(0.00001, panSpeed * radius);
+    const horizontal = scale3(right, -deltaX * scale);
+    const vertical = scale3(up, deltaY * scale);
+    return add3(horizontal, vertical);
+}
+export function buildCameraDefinitionFromThreeCamera(camera, aspect) {
+    const position = [camera.position.x, camera.position.y, camera.position.z];
+    const up = [camera.up.x, camera.up.y, camera.up.z];
+    const worldDirection = new Vector3(0, 0, -1);
+    camera.getWorldDirection?.(worldDirection);
+    const target = [
+        position[0] + worldDirection.x,
+        position[1] + worldDirection.y,
+        position[2] + worldDirection.z,
+    ];
+    if (camera.isOrthographicCamera) {
+        return {
+            transform: { position, target, up },
+            projection: {
+                kind: "orthographic",
+                left: camera.left ?? -1,
+                right: camera.right ?? 1,
+                top: camera.top ?? 1,
+                bottom: camera.bottom ?? -1,
+                near: camera.near ?? 0.1,
+                far: camera.far ?? 2000,
+                aspect,
+            },
+        };
+    }
+    return {
+        transform: { position, target, up },
+        projection: {
+            kind: "perspective",
+            fovY: camera.fov ?? 50,
+            near: camera.near ?? 0.1,
+            far: camera.far ?? 2000,
+            aspect,
+        },
+    };
+}
+export function syncThreeCameraFromManagedState(camera, cameraState, aspect) {
+    const transform = cameraState.transform;
+    const up = transform.up ?? [0, 1, 0];
+    camera.position.set(transform.position[0], transform.position[1], transform.position[2]);
+    camera.up.set(up[0], up[1], up[2]);
+    camera.lookAt(transform.target[0], transform.target[1], transform.target[2]);
+    const projection = cameraState.projection;
+    if (projection.kind === "perspective" && camera.isPerspectiveCamera) {
+        camera.fov = projection.fovY;
+        camera.near = projection.near;
+        camera.far = projection.far;
+        camera.aspect = aspect;
+        camera.updateProjectionMatrix?.();
+        return;
+    }
+    if (projection.kind === "orthographic" && camera.isOrthographicCamera) {
+        const sourceAspect = projection.aspect || 1;
+        const aspectScale = sourceAspect > 0 ? aspect / sourceAspect : 1;
+        camera.left = projection.left * aspectScale;
+        camera.right = projection.right * aspectScale;
+        camera.top = projection.top;
+        camera.bottom = projection.bottom;
+        camera.near = projection.near;
+        camera.far = projection.far;
+        camera.updateProjectionMatrix?.();
+    }
+}
+export function ManagedCameraController({ manager, profile, cameraId = "main", enabled = true, }) {
+    const { camera, gl, size } = useThree();
+    const pointerRef = useRef({
+        active: false,
+        mode: null,
+        x: 0,
+        y: 0,
+    });
+    const managedThreeCamera = camera;
+    const aspect = resolveCameraAspect(size.width, size.height);
+    useEffect(() => {
+        const cameraDefinition = buildCameraDefinitionFromThreeCamera(managedThreeCamera, aspect);
+        if (manager.hasCamera(cameraId)) {
+            manager.updateCamera(cameraId, cameraDefinition);
+        }
+        else {
+            manager.registerCamera({
+                id: cameraId,
+                priority: 100,
+                ...cameraDefinition,
+            });
+        }
+        manager.activateCamera(cameraId);
+    }, [manager, cameraId, managedThreeCamera, aspect]);
+    useEffect(() => {
+        const registered = manager.getCamera(cameraId);
+        if (!registered) {
+            return;
+        }
+        if (registered.projection.kind === "perspective") {
+            manager.updateCamera(cameraId, {
+                projection: {
+                    ...registered.projection,
+                    aspect,
+                },
+            });
+            return;
+        }
+        manager.updateCamera(cameraId, {
+            projection: {
+                ...registered.projection,
+                aspect,
+            },
+        });
+    }, [manager, cameraId, aspect]);
+    useEffect(() => {
+        if (!enabled) {
+            pointerRef.current.active = false;
+            pointerRef.current.mode = null;
+            return;
+        }
+        const element = gl.domElement;
+        if (!element) {
+            return;
+        }
+        const onPointerDown = (event) => {
+            if (event.button === 0 && !event.shiftKey) {
+                pointerRef.current.mode = "orbit";
+            }
+            else if (event.button === 2 || event.button === 1 || event.shiftKey) {
+                pointerRef.current.mode = "pan";
+            }
+            else {
+                pointerRef.current.mode = null;
+            }
+            if (!pointerRef.current.mode) {
+                return;
+            }
+            pointerRef.current.active = true;
+            pointerRef.current.x = event.clientX;
+            pointerRef.current.y = event.clientY;
+            element.setPointerCapture?.(event.pointerId);
+        };
+        const onPointerMove = (event) => {
+            if (!pointerRef.current.active || !pointerRef.current.mode) {
+                return;
+            }
+            const deltaX = event.clientX - pointerRef.current.x;
+            const deltaY = event.clientY - pointerRef.current.y;
+            pointerRef.current.x = event.clientX;
+            pointerRef.current.y = event.clientY;
+            if (pointerRef.current.mode === "orbit") {
+                manager.applyControl(cameraId, {
+                    type: "orbit",
+                    deltaAzimuth: -deltaX * profile.orbitSpeed,
+                    deltaPolar: -deltaY * profile.orbitSpeed,
+                }, {
+                    minDistance: profile.minDistance,
+                    maxDistance: profile.maxDistance,
+                    minPolarAngle: profile.minPolarAngle,
+                    maxPolarAngle: profile.maxPolarAngle,
+                    makeActive: true,
+                });
+                return;
+            }
+            const activeCamera = manager.getCamera(cameraId);
+            if (!activeCamera) {
+                return;
+            }
+            const delta = derivePanDeltaFromCameraState(activeCamera, deltaX, deltaY, profile.panSpeed);
+            manager.applyControl(cameraId, {
+                type: "pan",
+                delta,
+            }, { makeActive: true });
+        };
+        const onPointerUp = (event) => {
+            pointerRef.current.active = false;
+            pointerRef.current.mode = null;
+            element.releasePointerCapture?.(event.pointerId);
+        };
+        const onWheel = (event) => {
+            event.preventDefault();
+            const activeCamera = manager.getCamera(cameraId);
+            if (!activeCamera) {
+                return;
+            }
+            const distanceToTarget = Math.max(0.01, length3(sub3(activeCamera.transform.position, activeCamera.transform.target)));
+            const step = -event.deltaY * profile.dollySpeed * Math.max(0.05, distanceToTarget * 0.2);
+            manager.applyControl(cameraId, { type: "dolly", distance: step }, {
+                minDistance: profile.minDistance,
+                maxDistance: profile.maxDistance,
+                makeActive: true,
+            });
+        };
+        const onContextMenu = (event) => {
+            event.preventDefault();
+        };
+        element.addEventListener("pointerdown", onPointerDown);
+        window.addEventListener("pointermove", onPointerMove);
+        window.addEventListener("pointerup", onPointerUp);
+        element.addEventListener("wheel", onWheel, { passive: false });
+        element.addEventListener("contextmenu", onContextMenu);
+        return () => {
+            element.removeEventListener("pointerdown", onPointerDown);
+            window.removeEventListener("pointermove", onPointerMove);
+            window.removeEventListener("pointerup", onPointerUp);
+            element.removeEventListener("wheel", onWheel);
+            element.removeEventListener("contextmenu", onContextMenu);
+        };
+    }, [manager, cameraId, profile, gl, enabled]);
+    useFrame(() => {
+        const snapshot = manager.getSnapshot();
+        const activeId = snapshot.activeCameraId ?? cameraId;
+        const activeCamera = manager.getCamera(activeId);
+        if (!activeCamera) {
+            return;
+        }
+        syncThreeCameraFromManagedState(managedThreeCamera, activeCamera, aspect);
+    });
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import "./shaders/landscapeShader.js";
+export * from "./renderer.js";
+export * from "./worldSpaceCompositor.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+import "./shaders/landscapeShader.js";
+export * from "./renderer.js";
+export * from "./worldSpaceCompositor.js";

package/dist/landscape.d.ts

@@ -0,0 +1,2 @@
+export declare function Landscape(): import("react").JSX.Element;
+//# sourceMappingURL=landscape.d.ts.map

package/dist/landscape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"landscape.d.ts","sourceRoot":"","sources":["../src/landscape.tsx"],"names":[],"mappings":"AA4GA,wBAAgB,SAAS,gCAsDxB"}

package/dist/landscape.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as THREE from "three";
+import { useMemo } from "react";
+import * as BufferGeometryUtils from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { RigidBody } from "@react-three/rapier";
+const HEX_RADIUS = 66;
+//const TILE_RESOLUTION = 2048;
+const AREA_WIDTH = 2000;
+const AREA_HEIGHT = 2000;
+// Generate a single high-resolution hexagon as BufferGeometry
+function generateHexTile(radius) {
+    const geom = new THREE.BufferGeometry();
+    const vertices = [];
+    const indices = [];
+    const segments = 30; // More segments for smoother curve
+    const angleStep = (Math.PI * 2) / segments;
+    // Center point
+    vertices.push(0, 0, 0);
+    // Outer ring vertices
+    for (let i = 0; i <= segments; i++) {
+        const angle = angleStep * i;
+        const x = radius * Math.cos(angle);
+        const z = -radius * Math.sin(angle); // flip Z axis for pointy top upward
+        vertices.push(x, 0, z);
+    }
+    // Create triangle fan indices
+    for (let i = 1; i <= segments; i++) {
+        indices.push(0, i, i + 1);
+    }
+    geom.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
+    geom.setIndex(indices);
+    geom.computeVertexNormals();
+    return geom;
+}
+// Axial to world coordinates (pointy-topped hex)
+function axialToWorld(q, r, radius) {
+    const x = ((radius * 3) / 2) * q;
+    const z = radius * Math.sqrt(3) * (r + q / 2);
+    return [x, z];
+}
+// Simple seeded noise for per-tile deformation
+function seededNoise(x, z, seed = 42) {
+    const s = Math.sin(x * 12.9898 + z * 78.233 + seed) * 43758.5453;
+    return (s - Math.floor(s)) * 2 - 1;
+}
+// Deform only the interior (non-edge) vertices of a hex tile
+function deformHexInterior(geom, radius, seed = 42) {
+    const pos = geom.attributes.position;
+    const vertexCount = pos.count;
+    for (let i = 0; i < vertexCount; i++) {
+        const x = pos.getX(i);
+        const z = pos.getZ(i);
+        const r = Math.sqrt(x * x + z * z);
+        // Only deform vertices inside the hex edge (leave edge vertices flat)
+        if (r < radius * 0.98) {
+            // Blend multiple nearby noise samples for smoother curvature
+            const n = (dx, dz) => seededNoise(x + dx, z + dz, seed);
+            const smoothY = (n(0, 0) * 4 +
+                n(-1, 0) +
+                n(1, 0) +
+                n(0, -1) +
+                n(0, 1) +
+                n(-1, -1) +
+                n(1, 1) +
+                n(-1, 1) +
+                n(1, -1)) /
+                12;
+            pos.setY(i, smoothY);
+        }
+    }
+    pos.needsUpdate = true;
+    geom.computeVertexNormals();
+}
+function generateHexDepthMap(cols, rows, seed = 42) {
+    const map = [];
+    for (let q = 0; q < cols; q++) {
+        const row = [];
+        for (let r = 0; r < rows; r++) {
+            const value = Math.sin((q + seed) * 0.3) * Math.cos((r + seed) * 0.3);
+            row.push(value);
+        }
+        map.push(row);
+    }
+    return map;
+}
+export function Landscape() {
+    const geometry = useMemo(() => {
+        const radius = HEX_RADIUS;
+        const tiles = [];
+        const spacingX = (3 / 2) * radius;
+        const spacingZ = Math.sqrt(3) * radius;
+        const cols = Math.ceil(AREA_WIDTH / spacingX);
+        const rows = Math.ceil(AREA_HEIGHT / spacingZ);
+        const offset = Math.floor(cols / 2);
+        const depthMap = generateHexDepthMap(cols, rows);
+        const elevationScale = 20;
+        const baseHex = generateHexTile(radius);
+        for (let q = -Math.floor(cols / 2); q < Math.ceil(cols / 2); q++) {
+            for (let r = -Math.floor(rows / 2); r < Math.ceil(rows / 2); r++) {
+                const hex = baseHex.clone();
+                const dq = q + offset;
+                const dr = r + offset;
+                const elevation = depthMap?.[dq]?.[dr] ?? 0;
+                deformHexInterior(hex, radius, 42 + q * 1000 + r + Math.floor(elevation * 100));
+                const [x, z] = axialToWorld(q, r, radius);
+                hex.translate(x, elevation * elevationScale, z);
+                tiles.push(hex);
+            }
+        }
+        const merged = BufferGeometryUtils.mergeGeometries(tiles, false);
+        // Remove normals before merging vertices to ensure proper welding
+        if (merged.attributes.normal) {
+            merged.deleteAttribute("normal");
+        }
+        const stitched = BufferGeometryUtils.mergeVertices(merged, 1e-2);
+        stitched.computeVertexNormals();
+        return stitched;
+    }, []);
+    return (_jsx(RigidBody, { type: "fixed", colliders: "trimesh", children: _jsx("mesh", { geometry: geometry, castShadow: true, receiveShadow: true, children: _jsx("landscapeShaderMaterial", { color: "#77aa66" }) }) }));
+}

package/dist/player/player.d.ts

@@ -0,0 +1,8 @@
+import React, { type PropsWithChildren } from "react";
+import type { CameraManager } from "@plasius/gpu-camera";
+declare function WrappedPlayer({ cameraManager, cameraId, children, }: PropsWithChildren<{
+    cameraManager: CameraManager;
+    cameraId: string;
+}>): React.JSX.Element;
+export { WrappedPlayer as Player };
+//# sourceMappingURL=player.d.ts.map

package/dist/player/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../../src/player/player.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAqB,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,qBAAqB,CAAC;AAiP/D,iBAAS,aAAa,CAAC,EACrB,aAAa,EACb,QAAQ,EACR,QAAQ,GACT,EAAE,iBAAiB,CAAC;IAAE,aAAa,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,qBAQvE;AAED,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,CAAC"}

package/dist/player/player.js

@@ -0,0 +1,203 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { PlayerStore } from "./playerstore.js";
+function length3(value) {
+    return Math.hypot(value[0], value[1], value[2]);
+}
+function normalize3(value, fallback) {
+    const len = length3(value);
+    if (len <= Number.EPSILON) {
+        return [...fallback];
+    }
+    return [value[0] / len, value[1] / len, value[2] / len];
+}
+function add3(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sub3(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross3(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    ];
+}
+function Player({ cameraManager, cameraId, children, }) {
+    // Local refs for movement-relevant stats (used by the rAF ticker)
+    const strRef = useRef(1);
+    const dexRef = useRef(1);
+    const endRef = useRef(1);
+    const movingKeys = useRef(new Set());
+    const movingRef = useRef(false);
+    const runLoadRef = useRef(0); // seconds of continuous run load
+    const lastTickRef = useRef(performance.now());
+    // Subscribe via inline selector (useSyncExternalStore under the hood)
+    const physEff = PlayerStore.useSelector((s) => {
+        const phys = s?.attributesBase?.physical ?? {
+            strength: 1,
+            dexterity: 1,
+            endurance: 1,
+        };
+        const g = s?.attributesGear ?? {};
+        const e = s?.attributesEffects ?? {};
+        let strength = (phys.strength ?? 1) + (g.strength ?? 0) + (e.strength ?? 0);
+        let dexterity = (phys.dexterity ?? 1) + (g.dexterity ?? 0) + (e.dexterity ?? 0);
+        let endurance = (phys.endurance ?? 1) + (g.endurance ?? 0) + (e.endurance ?? 0);
+        // Add equipped item modifiers
+        if (s?.equipment && s?.items) {
+            for (const slot of Object.keys(s.equipment)) {
+                const itemId = s.equipment[slot];
+                const item = s.items[itemId];
+                const m = item?.modifiers;
+                if (m) {
+                    strength += m.strength ?? 0;
+                    dexterity += m.dexterity ?? 0;
+                    endurance += m.endurance ?? 0;
+                }
+            }
+        }
+        // Add status effect attribute modifiers
+        if (s?.effects) {
+            for (const eff of Object.values(s.effects)) {
+                const mods = eff?.modifiers?.attributes;
+                if (mods) {
+                    strength += mods.strength ?? 0;
+                    dexterity += mods.dexterity ?? 0;
+                    endurance += mods.endurance ?? 0;
+                }
+            }
+        }
+        return { strength, dexterity, endurance };
+    });
+    // Keep refs in sync for rAF without causing extra renders
+    useEffect(() => {
+        strRef.current = physEff.strength;
+        dexRef.current = physEff.dexterity;
+        endRef.current = physEff.endurance;
+    }, [physEff.strength, physEff.dexterity, physEff.endurance]);
+    useEffect(() => {
+        window.focus();
+    }, []);
+    // Fatigue/exhaustion ticker
+    useEffect(() => {
+        let raf = 0;
+        const tick = () => {
+            const now = performance.now();
+            const dt = (now - lastTickRef.current) / 1000;
+            lastTickRef.current = now;
+            const ln = (x) => Math.log(1 + Math.max(0, x) / 25);
+            const endurance = endRef.current;
+            const recovery = 1.5 + ln(endurance); // recover faster with Endurance
+            if (movingRef.current) {
+                runLoadRef.current = Math.max(0, runLoadRef.current + dt);
+            }
+            else {
+                runLoadRef.current = Math.max(0, runLoadRef.current - dt * recovery);
+            }
+            raf = requestAnimationFrame(tick);
+        };
+        lastTickRef.current = performance.now();
+        raf = requestAnimationFrame(tick);
+        return () => cancelAnimationFrame(raf);
+    }, []);
+    // Movement handlers
+    useEffect(() => {
+        const ln = (x) => Math.log(1 + Math.max(0, x) / 25);
+        const baseSpeed = () => {
+            const dex = dexRef.current;
+            const str = strRef.current;
+            const dexBoost = 0.25 * ln(dex);
+            const strBoost = 0.1 * ln(str);
+            return 1 + dexBoost + strBoost;
+        };
+        const currentSpeed = () => {
+            const endurance = endRef.current;
+            const cap = 4 + 2 * ln(endurance);
+            const load = runLoadRef.current;
+            if (load <= cap)
+                return baseSpeed();
+            const over = Math.min(1, (load - cap) / cap);
+            const fatigue = 1 - 0.5 * over; // down to 50%
+            return baseSpeed() * fatigue;
+        };
+        const handleKeyDown = (event) => {
+            const cameraState = cameraManager.getCamera(cameraId);
+            if (!cameraState)
+                return;
+            const position = [...cameraState.transform.position];
+            const target = [...cameraState.transform.target];
+            const up = normalize3(cameraState.transform.up ?? [0, 1, 0], [0, 1, 0]);
+            const forward = normalize3(sub3(target, position), [0, 0, -1]);
+            const forwardY = forward[1];
+            const planarForward = normalize3([forward[0], 0, forward[2]], [0, 0, -1]);
+            const right = normalize3(cross3(planarForward, up), [1, 0, 0]);
+            const moveKeys = new Set(["w", "a", "s", "d", "q", "e"]);
+            if (moveKeys.has(event.key)) {
+                movingKeys.current.add(event.key);
+                movingRef.current = true;
+            }
+            switch (event.key) {
+                case "w":
+                    position[0] += planarForward[0] * currentSpeed();
+                    position[1] += planarForward[1] * currentSpeed();
+                    position[2] += planarForward[2] * currentSpeed();
+                    break;
+                case "s":
+                    position[0] -= planarForward[0] * currentSpeed();
+                    position[1] -= planarForward[1] * currentSpeed();
+                    position[2] -= planarForward[2] * currentSpeed();
+                    break;
+                case "a":
+                    position[0] -= right[0] * currentSpeed();
+                    position[1] -= right[1] * currentSpeed();
+                    position[2] -= right[2] * currentSpeed();
+                    break;
+                case "d":
+                    position[0] += right[0] * currentSpeed();
+                    position[1] += right[1] * currentSpeed();
+                    position[2] += right[2] * currentSpeed();
+                    break;
+                case "q":
+                    position[1] += currentSpeed();
+                    break;
+                case "e":
+                    position[1] -= currentSpeed();
+                    break;
+                default:
+                    break;
+            }
+            const nextTarget = add3(position, [
+                planarForward[0],
+                forwardY,
+                planarForward[2],
+            ]);
+            cameraManager.applyControl(cameraId, {
+                type: "set-look-at",
+                position,
+                target: nextTarget,
+                up,
+            }, { makeActive: true });
+        };
+        const handleKeyUp = (event) => {
+            const moveKeys = new Set(["w", "a", "s", "d", "q", "e"]);
+            if (moveKeys.has(event.key)) {
+                movingKeys.current.delete(event.key);
+                if (movingKeys.current.size === 0)
+                    movingRef.current = false;
+            }
+        };
+        window.addEventListener("keydown", handleKeyDown);
+        window.addEventListener("keyup", handleKeyUp);
+        return () => {
+            window.removeEventListener("keydown", handleKeyDown);
+            window.removeEventListener("keyup", handleKeyUp);
+        };
+    }, [cameraManager, cameraId]);
+    return _jsx(_Fragment, { children: children });
+}
+function WrappedPlayer({ cameraManager, cameraId, children, }) {
+    return (_jsx(PlayerStore.Provider, { children: _jsx(Player, { cameraManager: cameraManager, cameraId: cameraId, children: children }) }));
+}
+export { WrappedPlayer as Player };