@almadar/ui 5.140.0 → 5.142.0

package/dist/lib/drawable/three/index.cjs

@@ -4,9 +4,11 @@ var React3 = require('react');
 var providers = require('@almadar/ui/providers');
 var logger = require('@almadar/logger');
 var fiber = require('@react-three/fiber');
-var THREE9 = require('three');
+var THREE10 = require('three');
+var RoomEnvironment_js = require('three/examples/jsm/environments/RoomEnvironment.js');
 var drei = require('@react-three/drei');
 var jsxRuntime = require('react/jsx-runtime');
+var postprocessing = require('@react-three/postprocessing');
 var GLTFLoader = require('three/examples/jsm/loaders/GLTFLoader');
 var SkeletonUtils = require('three/examples/jsm/utils/SkeletonUtils');
 var clsx = require('clsx');
@@ -14,7 +16,6 @@ var tailwindMerge = require('tailwind-merge');
 var OrbitControls_js = require('three/examples/jsm/controls/OrbitControls.js');
 var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
 var OBJLoader_js = require('three/examples/jsm/loaders/OBJLoader.js');
-var postprocessing = require('@react-three/postprocessing');
 var hooks = require('@almadar/ui/hooks');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -38,7 +39,7 @@ function _interopNamespace(e) {
 }
 
 var React3__default = /*#__PURE__*/_interopDefault(React3);
-var THREE9__namespace = /*#__PURE__*/_interopNamespace(THREE9);
+var THREE10__namespace = /*#__PURE__*/_interopNamespace(THREE10);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -189,6 +190,7 @@ function collectDrawnItems(nodes) {
       case "draw-shape":
       case "draw-text":
       case "draw-group":
+      case "draw-mesh":
         if (isValidScenePos(n.position)) out.push({ pos: n.position, id: n.id });
         break;
       case "draw-sprite-layer":
@@ -473,6 +475,10 @@ function Lighting3D({
   directionalIntensity = 0.8,
   directionalColor = "#ffffff",
   directionalPosition = [10, 20, 10],
+  hemisphereIntensity = 0.3,
+  hemisphereColor = "#87ceeb",
+  hemisphereGroundColor = "#362d1d",
+  points,
   shadows = true,
   shadowMapSize = 2048,
   shadowCameraSize = 20,
@@ -505,22 +511,63 @@ function Lighting3D({
     /* @__PURE__ */ jsxRuntime.jsx(
       "hemisphereLight",
       {
-        intensity: 0.3,
-        color: "#87ceeb",
-        groundColor: "#362d1d"
+        intensity: hemisphereIntensity,
+        color: hemisphereColor,
+        groundColor: hemisphereGroundColor
       }
     ),
+    points?.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+      "pointLight",
+      {
+        position: p.position,
+        intensity: p.intensity,
+        color: p.color,
+        distance: p.distance,
+        decay: p.decay
+      },
+      i
+    )),
     showHelpers && /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(
       "directionalLightHelper",
       {
         args: [
-          new THREE9__namespace.DirectionalLight(directionalColor, directionalIntensity),
+          new THREE10__namespace.DirectionalLight(directionalColor, directionalIntensity),
           5
         ]
       }
     ) })
   ] });
 }
+function Effects3D({ post }) {
+  if (!post || !post.bloom && !post.vignette) return null;
+  const passes = [];
+  if (post.bloom) {
+    passes.push(
+      /* @__PURE__ */ jsxRuntime.jsx(
+        postprocessing.Bloom,
+        {
+          intensity: post.bloom.intensity ?? 1,
+          luminanceThreshold: post.bloom.threshold ?? 0.9,
+          luminanceSmoothing: post.bloom.smoothing ?? 0.3
+        },
+        "bloom"
+      )
+    );
+  }
+  if (post.vignette) {
+    passes.push(
+      /* @__PURE__ */ jsxRuntime.jsx(
+        postprocessing.Vignette,
+        {
+          offset: post.vignette.offset ?? 0.3,
+          darkness: post.vignette.darkness ?? 0.6
+        },
+        "vignette"
+      )
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(postprocessing.EffectComposer, { children: passes });
+}
 function CameraController3D({
   onCameraChange
 }) {
@@ -541,8 +588,8 @@ function FollowCamera3D({
   offset
 }) {
   const { camera } = fiber.useThree();
-  const look = React3.useRef(new THREE9__namespace.Vector3(target[0], target[1], target[2]));
-  const goal = React3.useRef(new THREE9__namespace.Vector3());
+  const look = React3.useRef(new THREE10__namespace.Vector3(target[0], target[1], target[2]));
+  const goal = React3.useRef(new THREE10__namespace.Vector3());
   fiber.useFrame((_, delta) => {
     const t = Math.min(1, delta * 5);
     goal.current.set(target[0] + offset[0], target[1] + offset[1], target[2] + offset[2]);
@@ -553,6 +600,88 @@ function FollowCamera3D({
   return null;
 }
 
+// lib/drawable/projector3d.ts
+function create3DProjector(opts = {}) {
+  const cellSize = opts.cellSize ?? 1;
+  const offsetX = opts.offsetX ?? 0;
+  const offsetZ = opts.offsetZ ?? 0;
+  return {
+    cellSize,
+    toWorld: (pos) => [pos.x * cellSize + offsetX, pos.z ?? 0, pos.y * cellSize + offsetZ]
+  };
+}
+var NUMERIC_TRACKS = [
+  "offsetX",
+  "offsetY",
+  "rotate",
+  "opacity",
+  "radiusX",
+  "radiusY",
+  "width",
+  "height",
+  "strokeWidth",
+  "strokeDashOffset",
+  "blur"
+];
+function isAnimatedShape(node) {
+  return Boolean(node.animation && node.animation.durationMs > 0 && node.animation.keyframes.length > 0);
+}
+var lerp = (a, b, k) => a + (b - a) * k;
+function applyShapeAnimation(node, timeMs) {
+  const anim = node.animation;
+  if (!anim || !(anim.durationMs > 0) || anim.keyframes.length === 0) return node;
+  const frames = [...anim.keyframes].sort((a, b) => a.at - b.at);
+  const cycle = timeMs / anim.durationMs;
+  const t = anim.loop === false ? Math.min(cycle, 1) : cycle - Math.floor(cycle);
+  const out = { ...node };
+  const trackValue = (key) => {
+    const defined = frames.filter((f) => f[key] !== void 0);
+    if (defined.length === 0) return void 0;
+    let prev;
+    let next;
+    for (const f of defined) {
+      if (f.at <= t) prev = f;
+      else if (!next) next = f;
+    }
+    if (!prev) return defined[0][key];
+    if (!next) return prev[key];
+    const span = next.at - prev.at;
+    const k = span > 0 ? (t - prev.at) / span : 1;
+    const a = prev[key];
+    const b = next[key];
+    if (typeof a === "number" && typeof b === "number") return lerp(a, b, k);
+    return a;
+  };
+  for (const key of NUMERIC_TRACKS) {
+    const v = trackValue(key);
+    if (v !== void 0) out[key] = v;
+  }
+  const fill = trackValue("fill");
+  if (fill !== void 0) out.fill = fill;
+  const stroke = trackValue("stroke");
+  if (stroke !== void 0) out.stroke = stroke;
+  const shadowFrames = frames.filter((f) => f.shadow !== void 0);
+  if (shadowFrames.length > 0) {
+    const sh = trackValue("shadow");
+    if (sh !== void 0) {
+      let prevSh;
+      let nextSh;
+      for (const f of shadowFrames) {
+        if (f.at <= t) prevSh = f;
+        else if (!nextSh) nextSh = f;
+      }
+      if (prevSh?.shadow && nextSh?.shadow) {
+        const span = nextSh.at - prevSh.at;
+        const k = span > 0 ? (t - prevSh.at) / span : 1;
+        out.shadow = { color: prevSh.shadow.color, blur: lerp(prevSh.shadow.blur, nextSh.shadow.blur, k) };
+      } else {
+        out.shadow = sh;
+      }
+    }
+  }
+  return out;
+}
+
 // lib/atlasSlice.ts
 var atlasCache = /* @__PURE__ */ new Map();
 function isTilesheet(a) {
@@ -687,12 +816,12 @@ function ModelLoader({
     if (!loadedModel) return null;
     const cloned = SkeletonUtils.clone(loadedModel);
     cloned.updateMatrixWorld(true);
-    const tintColor = tint ? new THREE9__namespace.Color(tint) : null;
+    const tintColor = tint ? new THREE10__namespace.Color(tint) : null;
     cloned.traverse((child) => {
-      if (child instanceof THREE9__namespace.Mesh) {
+      if (child instanceof THREE10__namespace.Mesh) {
         child.castShadow = castShadow;
         child.receiveShadow = receiveShadow;
-        if (tintColor && child.material instanceof THREE9__namespace.MeshStandardMaterial) {
+        if (tintColor && child.material instanceof THREE10__namespace.MeshStandardMaterial) {
           const mat = child.material.clone();
           mat.color.multiply(tintColor);
           child.material = mat;
@@ -701,7 +830,7 @@ function ModelLoader({
     });
     return cloned;
   }, [loadedModel, castShadow, receiveShadow, tint]);
-  const mixer = React3.useMemo(() => model ? new THREE9__namespace.AnimationMixer(model) : null, [model]);
+  const mixer = React3.useMemo(() => model ? new THREE10__namespace.AnimationMixer(model) : null, [model]);
   React3.useEffect(() => {
     if (!mixer || !animation || clips.length === 0) return;
     const wanted = animation.toLowerCase();
@@ -718,8 +847,8 @@ function ModelLoader({
   });
   const normFactor = React3.useMemo(() => {
     if (!model) return 1;
-    const box = new THREE9__namespace.Box3().setFromObject(model);
-    const size = new THREE9__namespace.Vector3();
+    const box = new THREE10__namespace.Box3().setFromObject(model);
+    const size = new THREE10__namespace.Vector3();
     box.getSize(size);
     const maxDim = Math.max(size.x, size.y, size.z);
     if (!Number.isFinite(maxDim) || maxDim < 0.05) return 1;
@@ -809,7 +938,7 @@ var warnUnsupported3d = (kind) => {
   warnedUnsupported.add(kind);
   mesh3dLog.warn("unsupported drawable kind on the 3D backend \u2014 skipped", { kind });
 };
-var CrossOriginTextureLoader = class extends THREE9__namespace.TextureLoader {
+var CrossOriginTextureLoader = class extends THREE10__namespace.TextureLoader {
   constructor() {
     super();
     this.crossOrigin = "anonymous";
@@ -827,7 +956,7 @@ function useBillboardTexture(url) {
       url,
       (texture) => {
         if (!active) return;
-        texture.colorSpace = THREE9__namespace.SRGBColorSpace;
+        texture.colorSpace = THREE10__namespace.SRGBColorSpace;
         setState({ texture, error: false });
       },
       void 0,
@@ -859,7 +988,7 @@ function useAtlasFrame(asset) {
     return { frame: { x: r.sx, y: r.sy, w: r.sw, h: r.sh }, ready: true };
   }, [asset, tick]);
 }
-function SpriteBillboard({ node, world, cellSize = 1 }) {
+function SpriteBillboard({ node, world, cellSize = 1, groupOpacity = 1 }) {
   const { texture, error: textureError } = useBillboardTexture(node.asset.url);
   const { frame: atlasFrame, ready: atlasReady } = useAtlasFrame(node.asset);
   const frame = node.frame ?? atlasFrame;
@@ -880,7 +1009,7 @@ function SpriteBillboard({ node, world, cellSize = 1 }) {
   }, [texture, frame, node.height, node.width, anchor, cellSize]);
   const groundGeometry = React3__default.default.useMemo(() => {
     if (anchor !== "top-left" || !texture || !atlasReady) return null;
-    const g = new THREE9__namespace.PlaneGeometry(size.width, size.height);
+    const g = new THREE10__namespace.PlaneGeometry(size.width, size.height);
     g.rotateX(-Math.PI / 2);
     return g;
   }, [anchor, texture, atlasReady, size.width, size.height]);
@@ -888,15 +1017,15 @@ function SpriteBillboard({ node, world, cellSize = 1 }) {
     if (anchor === "top-left") {
       return /* @__PURE__ */ jsxRuntime.jsx("group", { position: [world[0] + size.width / 2, 0.02, world[2] + size.height / 2], children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [-Math.PI / 2, 0, 0], children: [
         /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [size.width, size.height] }),
-        /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: textureError ? 16729156 : 8947848, transparent: true, opacity: 0.6, side: THREE9__namespace.DoubleSide })
+        /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: textureError ? 16729156 : 8947848, transparent: true, opacity: 0.6, side: THREE10__namespace.DoubleSide })
       ] }) });
     }
     return /* @__PURE__ */ jsxRuntime.jsx("group", { position: [world[0], world[1] + size.height / 2, world[2]], children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { children: [
       /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [size.width, size.height] }),
-      /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: textureError ? 16729156 : 8947848, transparent: true, opacity: 0.6, side: THREE9__namespace.DoubleSide })
+      /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: textureError ? 16729156 : 8947848, transparent: true, opacity: 0.6, side: THREE10__namespace.DoubleSide })
     ] }) });
   }
-  texture.magFilter = texture.minFilter = THREE9__namespace.NearestFilter;
+  texture.magFilter = texture.minFilter = THREE10__namespace.NearestFilter;
   texture.needsUpdate = true;
   if (frame) {
     texture.repeat.set(frame.w / size.imgW, frame.h / size.imgH);
@@ -909,8 +1038,8 @@ function SpriteBillboard({ node, world, cellSize = 1 }) {
         map: texture,
         transparent: true,
         alphaTest: 0.1,
-        side: THREE9__namespace.DoubleSide,
-        opacity: node.opacity ?? 1
+        side: THREE10__namespace.DoubleSide,
+        opacity: (node.opacity ?? 1) * groupOpacity
       }
     ) }) });
   }
@@ -922,13 +1051,13 @@ function SpriteBillboard({ node, world, cellSize = 1 }) {
         map: texture,
         transparent: true,
         alphaTest: 0.1,
-        side: THREE9__namespace.DoubleSide,
+        side: THREE10__namespace.DoubleSide,
         opacity: node.opacity ?? 1
       }
     )
   ] }) });
 }
-function Sprite3D({ node, projector }) {
+function Sprite3D({ node, projector, groupOpacity = 1 }) {
   const asset = node.asset;
   if (!asset?.url || !isValidScenePos(node.position)) return null;
   if (asset.dimension === "3d") {
@@ -942,7 +1071,7 @@ function Sprite3D({ node, projector }) {
       {
         url: asset.url,
         scale,
-        rotation: [0, node.rotation ?? 0, 0],
+        rotation: [0, (node.rotation ?? 0) * 180 / Math.PI, 0],
         animation: node.animation,
         fallbackGeometry: "box",
         castShadow: true,
@@ -950,11 +1079,30 @@ function Sprite3D({ node, projector }) {
       }
     ) });
   }
-  return /* @__PURE__ */ jsxRuntime.jsx(SpriteBillboard, { node, world: projector.toWorld(node.position), cellSize: projector.cellSize });
+  return /* @__PURE__ */ jsxRuntime.jsx(SpriteBillboard, { node, world: projector.toWorld(node.position), cellSize: projector.cellSize, groupOpacity });
 }
-function Shape3D({ node, projector }) {
-  if (!isValidScenePos(node.position)) return null;
-  const world = projector.toWorld(node.position);
+function Shape3D({ node, projector, groupOpacity = 1 }) {
+  const groupRef = React3__default.default.useRef(null);
+  const materialRef = React3__default.default.useRef(null);
+  const animated = isAnimatedShape(node);
+  const validPos = isValidScenePos(node.position);
+  const world = validPos ? projector.toWorld(node.position) : [0, 0, 0];
+  fiber.useFrame(({ clock }) => {
+    if (!animated || !groupRef.current) return;
+    const view = applyShapeAnimation(node, clock.elapsedTime * 1e3);
+    groupRef.current.position.set(
+      world[0] + (view.offsetX ?? 0) * projector.cellSize,
+      world[1] + 0.02,
+      world[2] + (view.offsetY ?? 0) * projector.cellSize
+    );
+    groupRef.current.rotation.y = -(view.rotate ?? 0);
+    const mat = materialRef.current;
+    if (mat) {
+      mat.opacity = (view.opacity ?? node.opacity ?? 1) * groupOpacity;
+      if (view.fill) mat.color.set(view.fill);
+    }
+  });
+  if (!validPos) return null;
   const color = node.fill ?? node.stroke ?? "#ffffff";
   let geometry;
   switch (node.shape) {
@@ -972,7 +1120,7 @@ function Shape3D({ node, projector }) {
     }
     case "poly": {
       if (!node.points || node.points.length === 0) return null;
-      const s = new THREE9__namespace.Shape();
+      const s = new THREE10__namespace.Shape();
       node.points.forEach((p, i) => {
         if (i === 0) s.moveTo(p.x, p.y);
         else s.lineTo(p.x, p.y);
@@ -988,12 +1136,12 @@ function Shape3D({ node, projector }) {
     default:
       return null;
   }
-  return /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [-Math.PI / 2, 0, 0], position: [world[0], world[1] + 0.02, world[2]], children: [
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { ref: groupRef, position: [world[0], world[1] + 0.02, world[2]], children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [-Math.PI / 2, 0, 0], children: [
     geometry,
-    /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color, transparent: true, opacity: node.opacity ?? 1, side: THREE9__namespace.DoubleSide })
-  ] });
+    /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { ref: materialRef, color, transparent: true, opacity: (node.opacity ?? 1) * groupOpacity, side: THREE10__namespace.DoubleSide })
+  ] }) });
 }
-function Text3D({ node, projector }) {
+function Text3D({ node, projector, groupOpacity = 1 }) {
   if (!isValidScenePos(node.position)) return null;
   const world = projector.toWorld(node.position);
   return /* @__PURE__ */ jsxRuntime.jsx(drei.Billboard, { position: [world[0], world[1] + 1.2, world[2]], children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -1005,41 +1153,252 @@ function Text3D({ node, projector }) {
       anchorY: "middle",
       outlineWidth: 0.02,
       outlineColor: "#000000",
+      fillOpacity: groupOpacity,
+      outlineOpacity: groupOpacity,
       children: node.text
     }
   ) });
 }
-function Drawable3D({ node, projector }) {
+var MESH_SEGMENTS_DEFAULT = 24;
+function clampSegments(segments) {
+  const s = segments ?? MESH_SEGMENTS_DEFAULT;
+  return Math.min(64, Math.max(3, Math.round(s)));
+}
+function isAnimatedMesh(node) {
+  return Boolean(node.animation && node.animation.durationMs > 0 && node.animation.keyframes.length > 0);
+}
+var lerp2 = (a, b, k) => a + (b - a) * k;
+var NUMERIC_TRACKS2 = [
+  "offsetX",
+  "offsetY",
+  "offsetZ",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "scale",
+  "opacity",
+  "emissiveIntensity"
+];
+function applyMeshAnimation(node, timeMs) {
+  const anim = node.animation;
+  if (!anim || !(anim.durationMs > 0) || anim.keyframes.length === 0) return null;
+  const frames = [...anim.keyframes].sort((a, b) => a.at - b.at);
+  const cycle = timeMs / anim.durationMs;
+  const t = anim.loop === false ? Math.min(cycle, 1) : cycle - Math.floor(cycle);
+  const trackValue = (key) => {
+    const defined = frames.filter((f) => f[key] !== void 0);
+    if (defined.length === 0) return void 0;
+    let prev;
+    let next;
+    for (const f of defined) {
+      if (f.at <= t) prev = f;
+      else if (!next) next = f;
+    }
+    if (!prev) return defined[0][key];
+    if (!next) return prev[key];
+    const span = next.at - prev.at;
+    const k = span > 0 ? (t - prev.at) / span : 1;
+    const a = prev[key];
+    const b = next[key];
+    if (typeof a === "number" && typeof b === "number") return lerp2(a, b, k);
+    return a;
+  };
+  const num = {};
+  for (const key of NUMERIC_TRACKS2) {
+    const v = trackValue(key);
+    if (v !== void 0) num[key] = v;
+  }
+  return {
+    offset: [num.offsetX ?? 0, num.offsetY ?? 0, num.offsetZ ?? 0],
+    rotate: [num.rotateX ?? 0, num.rotateY ?? 0, num.rotateZ ?? 0],
+    scale: num.scale ?? 1,
+    opacity: num.opacity,
+    emissiveIntensity: num.emissiveIntensity,
+    color: trackValue("color"),
+    emissive: trackValue("emissive")
+  };
+}
+function meshGeometry(node, cellSize) {
+  const seg = clampSegments(node.segments);
+  const r = (node.radius ?? 0.4) * cellSize;
+  const w = (node.width ?? 1) * cellSize;
+  const h = (node.height ?? 1) * cellSize;
+  const d = (node.depth ?? node.width ?? 1) * cellSize;
+  switch (node.shape) {
+    case "box":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [w, h, d] }), lift: h / 2, size: Math.max(w, h, d) };
+    case "sphere":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [r, seg, seg] }), lift: r, size: r * 2 };
+    case "capsule":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("capsuleGeometry", { args: [r, h, Math.max(2, Math.round(seg / 2)), seg] }), lift: h / 2 + r, size: h + r * 2 };
+    case "cylinder":
+      return {
+        element: /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [(node.radiusTop ?? node.radius ?? 0.4) * cellSize, (node.radiusBottom ?? node.radius ?? 0.4) * cellSize, h, seg] }),
+        lift: h / 2,
+        size: Math.max(h, r * 2)
+      };
+    case "cone":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [r, h, seg] }), lift: h / 2, size: Math.max(h, r * 2) };
+    case "torus": {
+      const tube = (node.tube ?? (node.radius ?? 0.4) / 3) * cellSize;
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("torusGeometry", { args: [r, tube, Math.max(3, Math.round(seg / 2)), seg] }), lift: r + tube, size: (r + tube) * 2 };
+    }
+    case "plane":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [w, d] }), lift: 0, size: Math.max(w, d) };
+    case "circle":
+      return { element: /* @__PURE__ */ jsxRuntime.jsx("circleGeometry", { args: [r, seg] }), lift: 0, size: r * 2 };
+    default:
+      return null;
+  }
+}
+var SIDE_MAP = {
+  front: THREE10__namespace.FrontSide,
+  back: THREE10__namespace.BackSide,
+  double: THREE10__namespace.DoubleSide
+};
+function meshMaterial(mat, opacity, ref) {
+  const m = mat ?? {};
+  const common = {
+    ref,
+    color: m.color ?? "#ffffff",
+    transparent: opacity < 1,
+    opacity,
+    side: SIDE_MAP[m.side ?? "front"]
+  };
+  const emissive = m.emissive ? { emissive: m.emissive, emissiveIntensity: m.emissiveIntensity ?? 1 } : {};
+  switch (m.kind ?? "standard") {
+    case "basic":
+      return /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { ...common });
+    case "toon":
+      return /* @__PURE__ */ jsxRuntime.jsx("meshToonMaterial", { ...common, ...emissive });
+    case "physical":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "meshPhysicalMaterial",
+        {
+          ...common,
+          ...emissive,
+          metalness: m.metalness ?? 0,
+          roughness: m.roughness ?? 0.5,
+          transmission: m.transmission ?? 0,
+          ior: m.ior ?? 1.5,
+          flatShading: m.flatShading ?? false
+        }
+      );
+    case "standard":
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "meshStandardMaterial",
+        {
+          ...common,
+          ...emissive,
+          metalness: m.metalness ?? 0,
+          roughness: m.roughness ?? 0.5,
+          flatShading: m.flatShading ?? false
+        }
+      );
+  }
+}
+function Mesh3D({
+  node,
+  projector,
+  groupOpacity = 1
+}) {
+  const groupRef = React3.useRef(null);
+  const meshRef = React3.useRef(null);
+  const materialRef = React3.useRef(null);
+  const animated = isAnimatedMesh(node);
+  const validPos = isValidScenePos(node.position);
+  const baseWorld = validPos ? projector.toWorld(node.position) : [0, 0, 0];
+  const geo = React3.useMemo(() => meshGeometry(node, projector.cellSize), [node, projector.cellSize]);
+  fiber.useFrame(({ clock }) => {
+    if (!animated || !groupRef.current) return;
+    const state = applyMeshAnimation(node, clock.elapsedTime * 1e3);
+    if (!state) return;
+    const [wx, wy, wz] = baseWorld;
+    groupRef.current.position.set(
+      wx + state.offset[0] * projector.cellSize,
+      wy + state.offset[2] * projector.cellSize,
+      wz + state.offset[1] * projector.cellSize
+    );
+    groupRef.current.scale.setScalar(state.scale);
+    if (meshRef.current) {
+      const base = node.rotation ?? [0, 0, 0];
+      meshRef.current.rotation.set(base[0] + state.rotate[0], base[1] + state.rotate[1], base[2] + state.rotate[2]);
+    }
+    const mat = materialRef.current;
+    if (mat) {
+      const effective = (state.opacity ?? node.opacity ?? 1) * (node.material?.opacity ?? 1) * groupOpacity;
+      mat.opacity = effective;
+      mat.transparent = effective < 1;
+      if (state.color && mat.color) mat.color.set(state.color);
+      if (state.emissive && mat.emissive) mat.emissive.set(state.emissive);
+      if (state.emissiveIntensity !== void 0 && mat.emissiveIntensity !== void 0) {
+        mat.emissiveIntensity = state.emissiveIntensity;
+      }
+    }
+  });
+  if (!validPos || !geo) return null;
+  const lift = (node.pivot ?? "bottom") === "bottom" ? geo.lift : 0;
+  const opacity = (node.opacity ?? 1) * (node.material?.opacity ?? 1) * groupOpacity;
+  const rotation = node.rotation ?? [0, 0, 0];
+  const outlineScale = geo.size > 0 ? 1 + (node.outline?.width ?? 0.05) * projector.cellSize / geo.size : 1;
+  return /* @__PURE__ */ jsxRuntime.jsxs("group", { ref: groupRef, position: baseWorld, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "mesh",
+      {
+        ref: meshRef,
+        position: [0, lift, 0],
+        rotation,
+        castShadow: node.castShadow ?? true,
+        receiveShadow: node.receiveShadow ?? true,
+        children: [
+          geo.element,
+          meshMaterial(node.material, opacity, materialRef)
+        ]
+      }
+    ),
+    node.outline && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, lift, 0], rotation, scale: outlineScale, children: [
+      geo.element,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "meshBasicMaterial",
+        {
+          color: node.outline.color ?? "#101014",
+          side: THREE10__namespace.BackSide,
+          transparent: opacity < 1,
+          opacity
+        }
+      )
+    ] })
+  ] });
+}
+function Drawable3D({ node, projector, groupOpacity = 1 }) {
   switch (node.type) {
     case "draw-sprite":
-      return /* @__PURE__ */ jsxRuntime.jsx(Sprite3D, { node, projector });
+      return /* @__PURE__ */ jsxRuntime.jsx(Sprite3D, { node, projector, groupOpacity });
     case "draw-shape":
-      return /* @__PURE__ */ jsxRuntime.jsx(Shape3D, { node, projector });
+      return /* @__PURE__ */ jsxRuntime.jsx(Shape3D, { node, projector, groupOpacity });
     case "draw-text":
-      return /* @__PURE__ */ jsxRuntime.jsx(Text3D, { node, projector });
+      return /* @__PURE__ */ jsxRuntime.jsx(Text3D, { node, projector, groupOpacity });
+    case "draw-mesh":
+      return /* @__PURE__ */ jsxRuntime.jsx(Mesh3D, { node, projector, groupOpacity });
     case "draw-sprite-layer":
-      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Sprite3D, { node: item, projector }, i)) });
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Sprite3D, { node: item, projector, groupOpacity }, i)) });
     case "draw-shape-layer":
-      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Shape3D, { node: item, projector }, i)) });
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Shape3D, { node: item, projector, groupOpacity }, i)) });
     case "draw-text-layer":
-      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Text3D, { node: item, projector }, i)) });
-    case "draw-group":
-      warnUnsupported3d("draw-group");
-      return null;
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Text3D, { node: item, projector, groupOpacity }, i)) });
+    case "draw-group": {
+      if (!isValidScenePos(node.position) || !Array.isArray(node.items)) return null;
+      if (node.clip) warnUnsupported3d("draw-group:clip");
+      const world = projector.toWorld(node.position);
+      const inner = create3DProjector({ cellSize: projector.cellSize });
+      const opacity = (node.opacity ?? 1) * groupOpacity;
+      const s = node.scale ?? 1;
+      return /* @__PURE__ */ jsxRuntime.jsx("group", { position: world, rotation: [0, -(node.rotate ?? 0), 0], scale: [s, s, s], children: node.items.map((item, i) => /* @__PURE__ */ jsxRuntime.jsx(Drawable3D, { node: item, projector: inner, groupOpacity: opacity }, i)) });
+    }
   }
 }
 
-// lib/drawable/projector3d.ts
-function create3DProjector(opts = {}) {
-  const cellSize = opts.cellSize ?? 1;
-  const offsetX = opts.offsetX ?? 0;
-  const offsetZ = opts.offsetZ ?? 0;
-  return {
-    cellSize,
-    toWorld: (pos) => [pos.x * cellSize + offsetX, pos.z ?? 0, pos.y * cellSize + offsetZ]
-  };
-}
-
 // lib/drawable/three/game3dTheme.ts
 var GRID_COLORS_3D = {
   cell: "#444444",
@@ -1051,6 +1410,20 @@ function cn(...inputs) {
 }
 var DEFAULT_GRID_CONFIG = {
   cellSize: 1};
+function RoomEnvironment3D() {
+  const { gl, scene } = fiber.useThree(({ gl: gl2, scene: scene2 }) => ({ gl: gl2, scene: scene2 }));
+  React3.useEffect(() => {
+    const pmremGenerator = new THREE10__namespace.PMREMGenerator(gl);
+    const envTexture = pmremGenerator.fromScene(new RoomEnvironment_js.RoomEnvironment(), 0.04).texture;
+    scene.environment = envTexture;
+    return () => {
+      scene.environment = null;
+      envTexture.dispose();
+      pmremGenerator.dispose();
+    };
+  }, [gl, scene]);
+  return null;
+}
 var Canvas3DHost = React3.forwardRef(
   ({
     cameraMode = "isometric",
@@ -1075,6 +1448,9 @@ var Canvas3DHost = React3.forwardRef(
     keyMap,
     keyUpMap,
     pixelsPerUnit,
+    fov,
+    lighting,
+    post,
     children,
     drawables
   }, ref) => {
@@ -1083,6 +1459,7 @@ var Canvas3DHost = React3.forwardRef(
     const [internalError, setInternalError] = React3.useState(null);
     const eventBus = useEventBus();
     const keysRef = React3.useRef(/* @__PURE__ */ new Set());
+    const allDrawables = React3.useMemo(() => drawables ?? [], [drawables]);
     React3.useEffect(() => {
       if (!keyMap && !keyUpMap) return;
       const down = (e) => {
@@ -1116,7 +1493,7 @@ var Canvas3DHost = React3.forwardRef(
       unitAnimationEvent,
       cameraChangeEvent
     });
-    const drawnItems = React3.useMemo(() => collectDrawnItems(drawables ?? []), [drawables]);
+    const drawnItems = React3.useMemo(() => collectDrawnItems(allDrawables), [allDrawables]);
     const scenePositions = React3.useMemo(() => drawnItems.map((i) => i.pos), [drawnItems]);
     const hitIndex = React3.useMemo(() => buildHitIndex(drawnItems), [drawnItems]);
     const gridBounds = React3.useMemo(() => {
@@ -1164,7 +1541,7 @@ var Canvas3DHost = React3.forwardRef(
       getCameraPosition: () => {
         if (controlsRef.current) {
           const pos = controlsRef.current.object.position;
-          return new THREE9__namespace.Vector3(pos.x, pos.y, pos.z);
+          return new THREE10__namespace.Vector3(pos.x, pos.y, pos.z);
         }
         return null;
       },
@@ -1203,18 +1580,19 @@ var Canvas3DHost = React3.forwardRef(
       const cx = cameraTarget[0];
       const cz = cameraTarget[2];
       const d = size * 1;
+      const fovDeg = fov ?? 45;
       switch (cameraMode) {
         case "isometric":
-          return { position: [cx + d, d * 0.8, cz + d], fov: 45 };
+          return { position: [cx + d, d * 0.8, cz + d], fov: fovDeg };
         case "top-down":
-          return { position: [cx, d * 2, cz + d * 0.35], fov: 45 };
+          return { position: [cx, d * 2, cz + d * 0.35], fov: fovDeg };
         case "follow":
-          return { position: [cx, d * 0.5, cz + d], fov: 45 };
+          return { position: [cx, d * 0.5, cz + d], fov: fovDeg };
         case "perspective":
         default:
-          return { position: [cx + d, d, cz + d], fov: 45 };
+          return { position: [cx + d, d, cz + d], fov: fovDeg };
       }
-    }, [cameraMode, gridBounds, cellSize, cameraTarget]);
+    }, [cameraMode, gridBounds, cellSize, cameraTarget, fov]);
     const followWorld = React3.useMemo(() => {
       if (followTarget) return drawableProjector.toWorld(followTarget);
       return cameraTarget;
@@ -1297,9 +1675,19 @@ var Canvas3DHost = React3.forwardRef(
                       shadowNormalBias: 0.04,
                       shadowCameraSize: 5,
                       shadowCameraNear: 0.5,
-                      shadowCameraFar: 500
+                      shadowCameraFar: 500,
+                      ambientIntensity: lighting?.ambient?.intensity,
+                      ambientColor: lighting?.ambient?.color,
+                      directionalIntensity: lighting?.directional?.intensity,
+                      directionalColor: lighting?.directional?.color,
+                      directionalPosition: lighting?.directional?.position,
+                      hemisphereIntensity: lighting?.hemisphere?.intensity,
+                      hemisphereColor: lighting?.hemisphere?.color,
+                      hemisphereGroundColor: lighting?.hemisphere?.groundColor,
+                      points: lighting?.points
                     }
                   ),
+                  lighting?.environment === "room" && /* @__PURE__ */ jsxRuntime.jsx(RoomEnvironment3D, {}),
                   showGrid && /* @__PURE__ */ jsxRuntime.jsx(
                     drei.Grid,
                     {
@@ -1322,7 +1710,7 @@ var Canvas3DHost = React3.forwardRef(
                       fadeStrength: 1
                     }
                   ),
-                  drawables && drawables.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("group", { children: drawables.map((node, i) => /* @__PURE__ */ jsxRuntime.jsx(Drawable3D, { node, projector: drawableProjector }, i)) }),
+                  allDrawables.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("group", { children: allDrawables.map((node, i) => /* @__PURE__ */ jsxRuntime.jsx(Drawable3D, { node, projector: drawableProjector }, i)) }),
                   (tileClickEvent || unitClickEvent) && /* @__PURE__ */ jsxRuntime.jsxs(
                     "mesh",
                     {
@@ -1347,7 +1735,7 @@ var Canvas3DHost = React3.forwardRef(
                       ]
                     }
                   ),
-                  children,
+                  post && (post.bloom || post.vignette) ? /* @__PURE__ */ jsxRuntime.jsx(Effects3D, { post }) : null,
                   /* @__PURE__ */ jsxRuntime.jsx(
                     drei.OrbitControls,
                     {
@@ -1358,7 +1746,7 @@ var Canvas3DHost = React3.forwardRef(
                       dampingFactor: 0.05,
                       enableZoom: true,
                       enablePan: true,
-                      touches: { ONE: THREE9__namespace.TOUCH.ROTATE, TWO: THREE9__namespace.TOUCH.DOLLY_PAN },
+                      touches: { ONE: THREE10__namespace.TOUCH.ROTATE, TWO: THREE10__namespace.TOUCH.DOLLY_PAN },
                       minDistance: 2,
                       maxDistance: 100,
                       maxPolarAngle: Math.PI / 2 - 0.1
@@ -1381,15 +1769,15 @@ function Scene3D({ background = "#1a1a2e", fog, children }) {
     if (initializedRef.current) return;
     initializedRef.current = true;
     if (background.startsWith("#") || background.startsWith("rgb")) {
-      scene.background = new THREE9__namespace.Color(background);
+      scene.background = new THREE10__namespace.Color(background);
     } else {
-      const loader = new THREE9__namespace.TextureLoader();
+      const loader = new THREE10__namespace.TextureLoader();
       loader.load(background, (texture) => {
         scene.background = texture;
       });
     }
     if (fog) {
-      scene.fog = new THREE9__namespace.Fog(fog.color, fog.near, fog.far);
+      scene.fog = new THREE10__namespace.Fog(fog.color, fog.near, fog.far);
     }
     return () => {
       scene.background = null;
@@ -1412,14 +1800,14 @@ var Camera3D = React3.forwardRef(
   }, ref) => {
     const { camera, set, viewport } = fiber.useThree();
     const controlsRef = React3.useRef(null);
-    const initialPosition = React3.useRef(new THREE9__namespace.Vector3(...position));
-    const initialTarget = React3.useRef(new THREE9__namespace.Vector3(...target));
+    const initialPosition = React3.useRef(new THREE10__namespace.Vector3(...position));
+    const initialTarget = React3.useRef(new THREE10__namespace.Vector3(...target));
     React3.useEffect(() => {
       let newCamera;
       if (mode === "isometric") {
         const aspect = viewport.aspect;
         const size = 10 / zoom;
-        newCamera = new THREE9__namespace.OrthographicCamera(
+        newCamera = new THREE10__namespace.OrthographicCamera(
           -size * aspect,
           size * aspect,
           size,
@@ -1428,7 +1816,7 @@ var Camera3D = React3.forwardRef(
           1e3
         );
       } else {
-        newCamera = new THREE9__namespace.PerspectiveCamera(fov, viewport.aspect, 0.1, 1e3);
+        newCamera = new THREE10__namespace.PerspectiveCamera(fov, viewport.aspect, 0.1, 1e3);
       }
       newCamera.position.copy(initialPosition.current);
       newCamera.lookAt(initialTarget.current.x, initialTarget.current.y, initialTarget.current.z);
@@ -1469,8 +1857,8 @@ var Camera3D = React3.forwardRef(
         }
       },
       getViewBounds: () => {
-        const min = new THREE9__namespace.Vector3(-10, -10, -10);
-        const max = new THREE9__namespace.Vector3(10, 10, 10);
+        const min = new THREE10__namespace.Vector3(-10, -10, -10);
+        const max = new THREE10__namespace.Vector3(10, 10, 10);
         return { min, max };
       }
     }));
@@ -1512,7 +1900,7 @@ var AssetLoader = class {
     __publicField(this, "textureCache");
     __publicField(this, "loadingPromises");
     this.objLoader = new OBJLoader_js.OBJLoader();
-    this.textureLoader = new THREE9__namespace.TextureLoader();
+    this.textureLoader = new THREE10__namespace.TextureLoader();
     this.modelCache = /* @__PURE__ */ new Map();
     this.textureCache = /* @__PURE__ */ new Map();
     this.loadingPromises = /* @__PURE__ */ new Map();
@@ -1586,7 +1974,7 @@ var AssetLoader = class {
       return this.loadingPromises.get(`texture:${url}`);
     }
     const loadPromise = this.textureLoader.loadAsync(url).then((texture) => {
-      texture.colorSpace = THREE9__namespace.SRGBColorSpace;
+      texture.colorSpace = THREE10__namespace.SRGBColorSpace;
       this.textureCache.set(url, texture);
       this.loadingPromises.delete(`texture:${url}`);
       return texture;
@@ -1660,7 +2048,7 @@ var AssetLoader = class {
     });
     this.modelCache.forEach((model) => {
       model.scene.traverse((child) => {
-        if (child instanceof THREE9__namespace.Mesh) {
+        if (child instanceof THREE10__namespace.Mesh) {
           child.geometry.dispose();
           if (Array.isArray(child.material)) {
             child.material.forEach((m) => m.dispose());
@@ -1697,7 +2085,7 @@ var DEFAULT_OPTIONS = {
   gridSize: 20,
   assetLoader: new AssetLoader()
 };
-function useThree4(options = {}) {
+function useThree5(options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const containerRef = React3.useRef(null);
   const canvasRef = React3.useRef(null);
@@ -1710,21 +2098,21 @@ function useThree4(options = {}) {
   const [isReady, setIsReady] = React3.useState(false);
   const [dimensions, setDimensions] = React3.useState({ width: 0, height: 0 });
   const initialCameraPosition = React3.useMemo(
-    () => new THREE9__namespace.Vector3(...opts.cameraPosition),
+    () => new THREE10__namespace.Vector3(...opts.cameraPosition),
     []
   );
   React3.useEffect(() => {
     if (!containerRef.current) return;
     const container = containerRef.current;
     const { clientWidth, clientHeight } = container;
-    const scene = new THREE9__namespace.Scene();
-    scene.background = new THREE9__namespace.Color(opts.backgroundColor);
+    const scene = new THREE10__namespace.Scene();
+    scene.background = new THREE10__namespace.Color(opts.backgroundColor);
     sceneRef.current = scene;
     let camera;
     const aspect = clientWidth / clientHeight;
     if (opts.cameraMode === "isometric") {
       const size = 10;
-      camera = new THREE9__namespace.OrthographicCamera(
+      camera = new THREE10__namespace.OrthographicCamera(
         -size * aspect,
         size * aspect,
         size,
@@ -1733,11 +2121,11 @@ function useThree4(options = {}) {
         1e3
       );
     } else {
-      camera = new THREE9__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
+      camera = new THREE10__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
     }
     camera.position.copy(initialCameraPosition);
     cameraRef.current = camera;
-    const renderer = new THREE9__namespace.WebGLRenderer({
+    const renderer = new THREE10__namespace.WebGLRenderer({
       antialias: true,
       alpha: true,
       canvas: canvasRef.current || void 0
@@ -1745,7 +2133,7 @@ function useThree4(options = {}) {
     renderer.setSize(clientWidth, clientHeight);
     renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
     renderer.shadowMap.enabled = opts.shadows;
-    renderer.shadowMap.type = THREE9__namespace.PCFSoftShadowMap;
+    renderer.shadowMap.type = THREE10__namespace.PCFSoftShadowMap;
     rendererRef.current = renderer;
     const controls = new OrbitControls_js.OrbitControls(camera, renderer.domElement);
     controls.enableDamping = true;
@@ -1754,16 +2142,16 @@ function useThree4(options = {}) {
     controls.maxDistance = 100;
     controls.maxPolarAngle = Math.PI / 2 - 0.1;
     controlsRef.current = controls;
-    const ambientLight = new THREE9__namespace.AmbientLight(16777215, 0.6);
+    const ambientLight = new THREE10__namespace.AmbientLight(16777215, 0.6);
     scene.add(ambientLight);
-    const directionalLight = new THREE9__namespace.DirectionalLight(16777215, 0.8);
+    const directionalLight = new THREE10__namespace.DirectionalLight(16777215, 0.8);
     directionalLight.position.set(10, 20, 10);
     directionalLight.castShadow = opts.shadows;
     directionalLight.shadow.mapSize.width = 2048;
     directionalLight.shadow.mapSize.height = 2048;
     scene.add(directionalLight);
     if (opts.showGrid) {
-      const gridHelper = new THREE9__namespace.GridHelper(
+      const gridHelper = new THREE10__namespace.GridHelper(
         opts.gridSize,
         opts.gridSize,
         4473924,
@@ -1781,10 +2169,10 @@ function useThree4(options = {}) {
     const handleResize = () => {
       const { clientWidth: width, clientHeight: height } = container;
       setDimensions({ width, height });
-      if (camera instanceof THREE9__namespace.PerspectiveCamera) {
+      if (camera instanceof THREE10__namespace.PerspectiveCamera) {
         camera.aspect = width / height;
         camera.updateProjectionMatrix();
-      } else if (camera instanceof THREE9__namespace.OrthographicCamera) {
+      } else if (camera instanceof THREE10__namespace.OrthographicCamera) {
         const aspect2 = width / height;
         const size = 10;
         camera.left = -size * aspect2;
@@ -1815,7 +2203,7 @@ function useThree4(options = {}) {
     let newCamera;
     if (opts.cameraMode === "isometric") {
       const size = 10;
-      newCamera = new THREE9__namespace.OrthographicCamera(
+      newCamera = new THREE10__namespace.OrthographicCamera(
         -size * aspect,
         size * aspect,
         size,
@@ -1824,7 +2212,7 @@ function useThree4(options = {}) {
         1e3
       );
     } else {
-      newCamera = new THREE9__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
+      newCamera = new THREE10__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
     }
     newCamera.position.copy(currentPos);
     cameraRef.current = newCamera;
@@ -2154,8 +2542,8 @@ function useSceneGraph() {
 }
 function useRaycaster(options) {
   const { camera, canvas, cellSize = 1, offsetX = 0, offsetZ = 0 } = options;
-  const raycaster = React3.useRef(new THREE9__namespace.Raycaster());
-  const mouse = React3.useRef(new THREE9__namespace.Vector2());
+  const raycaster = React3.useRef(new THREE10__namespace.Raycaster());
+  const mouse = React3.useRef(new THREE10__namespace.Vector2());
   const clientToNDC = React3.useCallback(
     (clientX, clientY) => {
       if (!canvas) {
@@ -2225,8 +2613,8 @@ function useRaycaster(options) {
       const ndc = clientToNDC(clientX, clientY);
       mouse.current.set(ndc.x, ndc.y);
       raycaster.current.setFromCamera(mouse.current, camera);
-      const plane = new THREE9__namespace.Plane(new THREE9__namespace.Vector3(0, 1, 0), 0);
-      const target = new THREE9__namespace.Vector3();
+      const plane = new THREE10__namespace.Plane(new THREE10__namespace.Vector3(0, 1, 0), 0);
+      const target = new THREE10__namespace.Vector3();
       const intersection = raycaster.current.ray.intersectPlane(plane, target);
       if (intersection) {
         const gridX = Math.round((target.x - offsetX) / cellSize);
@@ -2264,7 +2652,7 @@ function useRaycaster(options) {
         return {
           gridX: gridCoords.x,
           gridZ: gridCoords.z,
-          worldPosition: new THREE9__namespace.Vector3(
+          worldPosition: new THREE10__namespace.Vector3(
             gridCoords.x * cellSize + offsetX,
             0,
             gridCoords.z * cellSize + offsetZ
@@ -2294,7 +2682,7 @@ var DEFAULT_CONFIG = {
 };
 function gridToWorld(gridX, gridZ, config = DEFAULT_CONFIG) {
   const opts = { ...DEFAULT_CONFIG, ...config };
-  return new THREE9__namespace.Vector3(
+  return new THREE10__namespace.Vector3(
     gridX * opts.cellSize + opts.offsetX,
     opts.elevation,
     gridZ * opts.cellSize + opts.offsetZ
@@ -2308,17 +2696,17 @@ function worldToGrid(worldX, worldZ, config = DEFAULT_CONFIG) {
   };
 }
 function raycastToPlane(camera, mouseX, mouseY, planeY = 0) {
-  const raycaster = new THREE9__namespace.Raycaster();
-  const mouse = new THREE9__namespace.Vector2(mouseX, mouseY);
+  const raycaster = new THREE10__namespace.Raycaster();
+  const mouse = new THREE10__namespace.Vector2(mouseX, mouseY);
   raycaster.setFromCamera(mouse, camera);
-  const plane = new THREE9__namespace.Plane(new THREE9__namespace.Vector3(0, 1, 0), -planeY);
-  const target = new THREE9__namespace.Vector3();
+  const plane = new THREE10__namespace.Plane(new THREE10__namespace.Vector3(0, 1, 0), -planeY);
+  const target = new THREE10__namespace.Vector3();
   const intersection = raycaster.ray.intersectPlane(plane, target);
   return intersection ? target : null;
 }
 function raycastToObjects(camera, mouseX, mouseY, objects) {
-  const raycaster = new THREE9__namespace.Raycaster();
-  const mouse = new THREE9__namespace.Vector2(mouseX, mouseY);
+  const raycaster = new THREE10__namespace.Raycaster();
+  const mouse = new THREE10__namespace.Vector2(mouseX, mouseY);
   raycaster.setFromCamera(mouse, camera);
   const intersects = raycaster.intersectObjects(objects, true);
   return intersects.length > 0 ? intersects[0] : null;
@@ -2370,14 +2758,14 @@ function getCellsInRadius(centerX, centerZ, radius) {
   return cells;
 }
 function createGridHighlight(color = 16776960, opacity = 0.3) {
-  const geometry = new THREE9__namespace.PlaneGeometry(0.95, 0.95);
-  const material = new THREE9__namespace.MeshBasicMaterial({
+  const geometry = new THREE10__namespace.PlaneGeometry(0.95, 0.95);
+  const material = new THREE10__namespace.MeshBasicMaterial({
     color,
     transparent: true,
     opacity,
-    side: THREE9__namespace.DoubleSide
+    side: THREE10__namespace.DoubleSide
   });
-  const mesh = new THREE9__namespace.Mesh(geometry, material);
+  const mesh = new THREE10__namespace.Mesh(geometry, material);
   mesh.rotation.x = -Math.PI / 2;
   mesh.position.y = 0.01;
   return mesh;
@@ -2390,31 +2778,31 @@ function normalizeMouseCoordinates(clientX, clientY, element) {
   };
 }
 function isInFrustum(position, camera, padding = 0) {
-  const frustum = new THREE9__namespace.Frustum();
-  const projScreenMatrix = new THREE9__namespace.Matrix4();
+  const frustum = new THREE10__namespace.Frustum();
+  const projScreenMatrix = new THREE10__namespace.Matrix4();
   projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
   frustum.setFromProjectionMatrix(projScreenMatrix);
-  const sphere = new THREE9__namespace.Sphere(position, padding);
+  const sphere = new THREE10__namespace.Sphere(position, padding);
   return frustum.intersectsSphere(sphere);
 }
 function filterByFrustum(positions, camera, padding = 0) {
-  const frustum = new THREE9__namespace.Frustum();
-  const projScreenMatrix = new THREE9__namespace.Matrix4();
+  const frustum = new THREE10__namespace.Frustum();
+  const projScreenMatrix = new THREE10__namespace.Matrix4();
   projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
   frustum.setFromProjectionMatrix(projScreenMatrix);
   return positions.filter((position) => {
-    const sphere = new THREE9__namespace.Sphere(position, padding);
+    const sphere = new THREE10__namespace.Sphere(position, padding);
     return frustum.intersectsSphere(sphere);
   });
 }
 function getVisibleIndices(positions, camera, padding = 0) {
-  const frustum = new THREE9__namespace.Frustum();
-  const projScreenMatrix = new THREE9__namespace.Matrix4();
+  const frustum = new THREE10__namespace.Frustum();
+  const projScreenMatrix = new THREE10__namespace.Matrix4();
   const visible = /* @__PURE__ */ new Set();
   projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
   frustum.setFromProjectionMatrix(projScreenMatrix);
   positions.forEach((position, index) => {
-    const sphere = new THREE9__namespace.Sphere(position, padding);
+    const sphere = new THREE10__namespace.Sphere(position, padding);
     if (frustum.intersectsSphere(sphere)) {
       visible.add(index);
     }
@@ -2438,7 +2826,7 @@ function updateInstanceLOD(instancedMesh, positions, camera, lodDistances) {
   return lodIndices;
 }
 function cullInstancedMesh(instancedMesh, positions, visibleIndices) {
-  const dummy = new THREE9__namespace.Object3D();
+  const dummy = new THREE10__namespace.Object3D();
   let visibleCount = 0;
   positions.forEach((position, index) => {
     if (visibleIndices.has(index)) {
@@ -3605,25 +3993,25 @@ function orbitRingPositions(count, radius, tilt) {
   return positions;
 }
 function arcCurve3D(from, to, offset) {
-  const start = new THREE9.Vector3(...from);
-  const end = new THREE9.Vector3(...to);
-  const mid = new THREE9.Vector3().addVectors(start, end).multiplyScalar(0.5);
-  const dir = new THREE9.Vector3().subVectors(end, start).normalize();
-  const up = new THREE9.Vector3(0, 1, 0);
-  const perp = new THREE9.Vector3().crossVectors(dir, up).normalize();
+  const start = new THREE10.Vector3(...from);
+  const end = new THREE10.Vector3(...to);
+  const mid = new THREE10.Vector3().addVectors(start, end).multiplyScalar(0.5);
+  const dir = new THREE10.Vector3().subVectors(end, start).normalize();
+  const up = new THREE10.Vector3(0, 1, 0);
+  const perp = new THREE10.Vector3().crossVectors(dir, up).normalize();
   if (perp.length() < 1e-3) {
-    perp.crossVectors(dir, new THREE9.Vector3(1, 0, 0)).normalize();
+    perp.crossVectors(dir, new THREE10.Vector3(1, 0, 0)).normalize();
   }
   const control = mid.clone().add(perp.multiplyScalar(offset));
   control.y += Math.abs(offset) * 0.3;
-  return new THREE9.QuadraticBezierCurve3(start, control, end);
+  return new THREE10.QuadraticBezierCurve3(start, control, end);
 }
 function selfLoopCurve3D(position, loopRadius) {
-  const base = new THREE9.Vector3(...position);
-  const start = base.clone().add(new THREE9.Vector3(-loopRadius * 0.3, 0, 0));
-  const end = base.clone().add(new THREE9.Vector3(loopRadius * 0.3, 0, 0));
-  const control = base.clone().add(new THREE9.Vector3(0, loopRadius, 0));
-  return new THREE9.QuadraticBezierCurve3(start, control, end);
+  const base = new THREE10.Vector3(...position);
+  const start = base.clone().add(new THREE10.Vector3(-loopRadius * 0.3, 0, 0));
+  const end = base.clone().add(new THREE10.Vector3(loopRadius * 0.3, 0, 0));
+  const control = base.clone().add(new THREE10.Vector3(0, loopRadius, 0));
+  return new THREE10.QuadraticBezierCurve3(start, control, end);
 }
 function treeLayout3D(node, origin, horizontalSpacing, verticalSpacing = 2) {
   const results = [];
@@ -3790,7 +4178,7 @@ var Avl3DOrbitalNode = ({
     if (!groupRef.current) return;
     groupRef.current.rotation.y += delta * (hovered ? 0.4 : 0.2);
     groupRef.current.rotation.x += delta * 0.05;
-    currentScale.current = THREE9.MathUtils.damp(currentScale.current, targetScale, 6, delta);
+    currentScale.current = THREE10.MathUtils.damp(currentScale.current, targetScale, 6, delta);
   });
   const baseBrightness = 0.3 + Math.min(pageCount, 5) * 0.05;
   const emissiveIntensity = hovered ? 0.8 : baseBrightness;
@@ -4432,7 +4820,7 @@ var Avl3DStateNode = ({
   const targetScale = hovered ? 1.08 : 1;
   const currentScale = React3.useRef(1);
   fiber.useFrame((_, delta) => {
-    currentScale.current = THREE9.MathUtils.damp(currentScale.current, targetScale, 6, delta);
+    currentScale.current = THREE10.MathUtils.damp(currentScale.current, targetScale, 6, delta);
   });
   const scale = currentScale.current;
   return /* @__PURE__ */ jsxRuntime.jsxs("group", { position, children: [
@@ -4612,9 +5000,9 @@ var Avl3DTransitionArc = ({
     const guardPt = curve.getPoint(0.3);
     const arrowPt = curve.getPoint(0.9);
     const arrowTangent = curve.getTangent(0.9);
-    const upVec = new THREE9.Vector3(0, 1, 0);
-    const tangentVec = new THREE9.Vector3(arrowTangent.x, arrowTangent.y, arrowTangent.z).normalize();
-    const quat = new THREE9.Quaternion().setFromUnitVectors(upVec, tangentVec);
+    const upVec = new THREE10.Vector3(0, 1, 0);
+    const tangentVec = new THREE10.Vector3(arrowTangent.x, arrowTangent.y, arrowTangent.z).normalize();
+    const quat = new THREE10.Quaternion().setFromUnitVectors(upVec, tangentVec);
     const effectPositions2 = [];
     for (let ei = 0; ei < 4; ei++) {
       const t = 0.7 + ei * 0.05;
@@ -4838,14 +5226,14 @@ function operatorColor(label) {
   return "#4A90D9";
 }
 function edgeGeometry(parent, child) {
-  const p = new THREE9.Vector3(parent.x, parent.y, parent.z);
-  const c = new THREE9.Vector3(child.x, child.y, child.z);
-  const mid = new THREE9.Vector3().addVectors(p, c).multiplyScalar(0.5);
-  const dir = new THREE9.Vector3().subVectors(c, p);
+  const p = new THREE10.Vector3(parent.x, parent.y, parent.z);
+  const c = new THREE10.Vector3(child.x, child.y, child.z);
+  const mid = new THREE10.Vector3().addVectors(p, c).multiplyScalar(0.5);
+  const dir = new THREE10.Vector3().subVectors(c, p);
   const length = dir.length();
-  const yAxis = new THREE9.Vector3(0, 1, 0);
+  const yAxis = new THREE10.Vector3(0, 1, 0);
   const angle = yAxis.angleTo(dir.normalize());
-  const axis = new THREE9.Vector3().crossVectors(yAxis, dir).normalize();
+  const axis = new THREE10.Vector3().crossVectors(yAxis, dir).normalize();
   if (axis.length() < 1e-3) {
     return {
       position: [mid.x, mid.y, mid.z],
@@ -5221,12 +5609,12 @@ function useAvl3DConfig() {
 }
 function CameraController({ targetPosition, targetLookAt, animated }) {
   const { camera } = fiber.useThree();
-  const targetPosVec = React3.useRef(new THREE9__namespace.Vector3(...targetPosition));
-  const targetLookVec = React3.useRef(new THREE9__namespace.Vector3(...targetLookAt));
+  const targetPosVec = React3.useRef(new THREE10__namespace.Vector3(...targetPosition));
+  const targetLookVec = React3.useRef(new THREE10__namespace.Vector3(...targetLookAt));
   const isAnimating = React3.useRef(false);
   React3.useEffect(() => {
-    const newTarget = new THREE9__namespace.Vector3(...targetPosition);
-    const newLookAt = new THREE9__namespace.Vector3(...targetLookAt);
+    const newTarget = new THREE10__namespace.Vector3(...targetPosition);
+    const newLookAt = new THREE10__namespace.Vector3(...targetLookAt);
     if (!newTarget.equals(targetPosVec.current) || !newLookAt.equals(targetLookVec.current)) {
       targetPosVec.current.copy(newTarget);
       targetLookVec.current.copy(newLookAt);
@@ -5241,9 +5629,9 @@ function CameraController({ targetPosition, targetLookAt, animated }) {
   fiber.useFrame((_, delta) => {
     if (!isAnimating.current) return;
     const speed = 3;
-    camera.position.x = THREE9__namespace.MathUtils.damp(camera.position.x, targetPosVec.current.x, speed, delta);
-    camera.position.y = THREE9__namespace.MathUtils.damp(camera.position.y, targetPosVec.current.y, speed, delta);
-    camera.position.z = THREE9__namespace.MathUtils.damp(camera.position.z, targetPosVec.current.z, speed, delta);
+    camera.position.x = THREE10__namespace.MathUtils.damp(camera.position.x, targetPosVec.current.x, speed, delta);
+    camera.position.y = THREE10__namespace.MathUtils.damp(camera.position.y, targetPosVec.current.y, speed, delta);
+    camera.position.z = THREE10__namespace.MathUtils.damp(camera.position.z, targetPosVec.current.z, speed, delta);
     camera.lookAt(targetLookVec.current);
     const dist = camera.position.distanceTo(targetPosVec.current);
     if (dist < 0.05) {
@@ -5258,7 +5646,7 @@ function SceneFade({ animating, children }) {
   fiber.useFrame((_, delta) => {
     if (!groupRef.current) return;
     const target = animating ? 0 : 1;
-    opacityRef.current = THREE9__namespace.MathUtils.damp(opacityRef.current, target, 5, delta);
+    opacityRef.current = THREE10__namespace.MathUtils.damp(opacityRef.current, target, 5, delta);
     groupRef.current.visible = opacityRef.current > 0.05;
     const s = 0.9 + opacityRef.current * 0.1;
     groupRef.current.scale.setScalar(s);
@@ -5558,5 +5946,5 @@ exports.useAvl3DConfig = useAvl3DConfig;
 exports.useGameCanvas3DEvents = useGameCanvas3DEvents;
 exports.useRaycaster = useRaycaster;
 exports.useSceneGraph = useSceneGraph;
-exports.useThree = useThree4;
+exports.useThree = useThree5;
 exports.worldToGrid = worldToGrid;