@project-skymap/library 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -446,7 +446,8 @@ function createEngine({
     draggedNodeId: null,
     draggedStarIndex: -1,
     draggedDist: 2e3,
-    draggedGroup: null
+    draggedGroup: null,
+    tempArrangement: {}
   };
   const mouseNDC = new THREE4__namespace.Vector2();
   let isMouseInWindow = false;
@@ -693,7 +694,55 @@ function createEngine({
   const nodeById = /* @__PURE__ */ new Map();
   const starIndexToId = [];
   const dynamicLabels = [];
+  const hoverLabelMat = createSmartMaterial({
+    uniforms: {
+      uMap: { value: null },
+      uSize: { value: new THREE4__namespace.Vector2(1, 1) },
+      uAlpha: { value: 0 },
+      uAngle: { value: 0 }
+    },
+    vertexShaderBody: `
+            uniform vec2 uSize;
+            uniform float uAngle;
+            varying vec2 vUv;
+            void main() {
+                vUv = uv;
+                vec4 mvPos = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                vec4 projected = smartProject(mvPos);
+                
+                float c = cos(uAngle);
+                float s = sin(uAngle);
+                mat2 rot = mat2(c, -s, s, c);
+                vec2 offset = rot * (position.xy * uSize);
+                
+                projected.xy += offset / vec2(uAspect, 1.0);
+                gl_Position = projected;
+            }
+        `,
+    fragmentShader: `
+            uniform sampler2D uMap;
+            uniform float uAlpha;
+            varying vec2 vUv;
+            void main() {
+                float mask = getMaskAlpha();
+                if (mask < 0.01) discard;
+                vec4 tex = texture2D(uMap, vUv);
+                gl_FragColor = vec4(tex.rgb, tex.a * uAlpha * mask);
+            }
+        `,
+    transparent: true,
+    depthWrite: false,
+    depthTest: false
+    // Always on top of stars
+  });
+  const hoverLabelMesh = new THREE4__namespace.Mesh(new THREE4__namespace.PlaneGeometry(1, 1), hoverLabelMat);
+  hoverLabelMesh.visible = false;
+  hoverLabelMesh.renderOrder = 999;
+  hoverLabelMesh.frustumCulled = false;
+  root.add(hoverLabelMesh);
+  let currentHoverNodeId = null;
   let constellationLines = null;
+  let boundaryLines = null;
   let starPoints = null;
   function clearRoot() {
     for (const child of [...root.children]) {
@@ -709,6 +758,7 @@ function createEngine({
     starIndexToId.length = 0;
     dynamicLabels.length = 0;
     constellationLines = null;
+    boundaryLines = null;
     starPoints = null;
   }
   function createTextTexture(text, color = "#ffffff") {
@@ -734,7 +784,22 @@ function createEngine({
   function getPosition(n) {
     if (currentConfig?.arrangement) {
       const arr = currentConfig.arrangement[n.id];
-      if (arr) return new THREE4__namespace.Vector3(arr.position[0], arr.position[1], arr.position[2]);
+      if (arr) {
+        if (arr.position[2] === 0) {
+          const x = arr.position[0];
+          const y = arr.position[1];
+          const radius = currentConfig.layout?.radius ?? 2e3;
+          const r_norm = Math.min(1, Math.sqrt(x * x + y * y) / radius);
+          const phi = Math.atan2(y, x);
+          const theta = r_norm * (Math.PI / 2);
+          return new THREE4__namespace.Vector3(
+            Math.sin(theta) * Math.cos(phi),
+            Math.cos(theta),
+            Math.sin(theta) * Math.sin(phi)
+          ).multiplyScalar(radius);
+        }
+        return new THREE4__namespace.Vector3(arr.position[0], arr.position[1], arr.position[2]);
+      }
     }
     return new THREE4__namespace.Vector3(n.meta?.x ?? 0, n.meta?.y ?? 0, n.meta?.z ?? 0);
   }
@@ -750,6 +815,30 @@ function createEngine({
     scene.background = cfg.background && cfg.background !== "transparent" ? new THREE4__namespace.Color(cfg.background) : new THREE4__namespace.Color(0);
     const layoutCfg = { ...cfg.layout, radius: cfg.layout?.radius ?? 2e3 };
     const laidOut = computeLayoutPositions(model, layoutCfg);
+    const divisionPositions = /* @__PURE__ */ new Map();
+    if (cfg.arrangement) {
+      const divMap = /* @__PURE__ */ new Map();
+      for (const n of laidOut.nodes) {
+        if (n.level === 2 && n.parent) {
+          const list = divMap.get(n.parent) ?? [];
+          list.push(n);
+          divMap.set(n.parent, list);
+        }
+      }
+      for (const [divId, books] of divMap.entries()) {
+        const centroid = new THREE4__namespace.Vector3();
+        let count = 0;
+        for (const b of books) {
+          const p = getPosition(b);
+          centroid.add(p);
+          count++;
+        }
+        if (count > 0) {
+          centroid.divideScalar(count);
+          divisionPositions.set(divId, centroid);
+        }
+      }
+    }
     const starPositions = [];
     const starSizes = [];
     const starColors = [];
@@ -798,26 +887,36 @@ function createEngine({
         const colorIdx = Math.floor(Math.pow(Math.random(), 1.5) * SPECTRAL_COLORS.length);
         const c = SPECTRAL_COLORS[Math.min(colorIdx, SPECTRAL_COLORS.length - 1)];
         starColors.push(c.r, c.g, c.b);
-      } else if (n.level === 2) {
-        const color = "#ffffff";
+      }
+      if (n.level === 1 || n.level === 2 || n.level === 3) {
+        const color = n.level === 1 ? "#38bdf8" : "#ffffff";
         const texRes = createTextTexture(n.label, color);
         if (texRes) {
-          const baseScale = 0.05;
+          let baseScale = 0.05;
+          if (n.level === 1) baseScale = 0.08;
+          else if (n.level === 3) baseScale = 0.04;
           const size = new THREE4__namespace.Vector2(baseScale * texRes.aspect, baseScale);
           const mat = createSmartMaterial({
             uniforms: {
               uMap: { value: texRes.tex },
               uSize: { value: size },
-              uAlpha: { value: 0 }
+              uAlpha: { value: 0 },
+              uAngle: { value: 0 }
             },
             vertexShaderBody: `
                             uniform vec2 uSize;
+                            uniform float uAngle;
                             varying vec2 vUv;
                             void main() {
                                 vUv = uv;
                                 vec4 mvPos = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
                                 vec4 projected = smartProject(mvPos);
-                                vec2 offset = position.xy * uSize;
+                                
+                                float c = cos(uAngle);
+                                float s = sin(uAngle);
+                                mat2 rot = mat2(c, -s, s, c);
+                                vec2 offset = rot * (position.xy * uSize);
+                                
                                 projected.xy += offset / vec2(uAspect, 1.0);
                                 gl_Position = projected;
                             }
@@ -838,7 +937,17 @@ function createEngine({
             depthTest: true
           });
           const mesh = new THREE4__namespace.Mesh(new THREE4__namespace.PlaneGeometry(1, 1), mat);
-          const p = getPosition(n);
+          let p = getPosition(n);
+          if (n.level === 1) {
+            if (divisionPositions.has(n.id)) {
+              p.copy(divisionPositions.get(n.id));
+            }
+            const r = layoutCfg.radius * 0.95;
+            const angle = Math.atan2(p.z, p.x);
+            p.set(r * Math.cos(angle), 150, r * Math.sin(angle));
+          } else if (n.level === 3) {
+            p.multiplyScalar(1.002);
+          }
           mesh.position.set(p.x, p.y, p.z);
           mesh.scale.set(size.x, size.y, 1);
           mesh.frustumCulled = false;
@@ -917,9 +1026,9 @@ function createEngine({
       const lineGeo = new THREE4__namespace.BufferGeometry();
       lineGeo.setAttribute("position", new THREE4__namespace.Float32BufferAttribute(linePoints, 3));
       const lineMat = createSmartMaterial({
-        uniforms: { color: { value: new THREE4__namespace.Color(4478310) } },
+        uniforms: { color: { value: new THREE4__namespace.Color(11193599) } },
         vertexShaderBody: `uniform vec3 color; varying vec3 vColor; void main() { vColor = color; vec4 mvPosition = modelViewMatrix * vec4(position, 1.0); gl_Position = smartProject(mvPosition); vScreenPos = gl_Position.xy / gl_Position.w; }`,
-        fragmentShader: `varying vec3 vColor; void main() { float alphaMask = getMaskAlpha(); if (alphaMask < 0.01) discard; gl_FragColor = vec4(vColor, 0.2 * alphaMask); }`,
+        fragmentShader: `varying vec3 vColor; void main() { float alphaMask = getMaskAlpha(); if (alphaMask < 0.01) discard; gl_FragColor = vec4(vColor, 0.4 * alphaMask); }`,
         transparent: true,
         depthWrite: false,
         blending: THREE4__namespace.AdditiveBlending
@@ -952,17 +1061,73 @@ function createEngine({
         }
       });
       boundaryGeo.setAttribute("position", new THREE4__namespace.Float32BufferAttribute(bPoints, 3));
-      const boundaryLines = new THREE4__namespace.LineSegments(boundaryGeo, boundaryMat);
+      boundaryLines = new THREE4__namespace.LineSegments(boundaryGeo, boundaryMat);
       boundaryLines.frustumCulled = false;
       root.add(boundaryLines);
     }
+    if (cfg.polygons) {
+      const polyPoints = [];
+      const rBase = layoutCfg.radius;
+      for (const pts of Object.values(cfg.polygons)) {
+        if (pts.length < 2) continue;
+        for (let i = 0; i < pts.length; i++) {
+          const p1_2d = pts[i];
+          const p2_2d = pts[(i + 1) % pts.length];
+          if (!p1_2d || !p2_2d) continue;
+          const project2dTo3d = (p) => {
+            const x = p[0];
+            const y = p[1];
+            const r_norm = Math.sqrt(x * x + y * y);
+            const phi = Math.atan2(y, x);
+            const theta = r_norm * (Math.PI / 2);
+            return new THREE4__namespace.Vector3(
+              Math.sin(theta) * Math.cos(phi),
+              Math.cos(theta),
+              Math.sin(theta) * Math.sin(phi)
+            ).multiplyScalar(rBase);
+          };
+          const v1 = project2dTo3d(p1_2d);
+          const v2 = project2dTo3d(p2_2d);
+          polyPoints.push(v1.x, v1.y, v1.z);
+          polyPoints.push(v2.x, v2.y, v2.z);
+        }
+      }
+      if (polyPoints.length > 0) {
+        const polyGeo = new THREE4__namespace.BufferGeometry();
+        polyGeo.setAttribute("position", new THREE4__namespace.Float32BufferAttribute(polyPoints, 3));
+        const polyMat = createSmartMaterial({
+          uniforms: { color: { value: new THREE4__namespace.Color(3718648) } },
+          // Cyan-ish
+          vertexShaderBody: `uniform vec3 color; varying vec3 vColor; void main() { vColor = color; vec4 mvPosition = modelViewMatrix * vec4(position, 1.0); gl_Position = smartProject(mvPosition); vScreenPos = gl_Position.xy / gl_Position.w; }`,
+          fragmentShader: `varying vec3 vColor; void main() { float alphaMask = getMaskAlpha(); if (alphaMask < 0.01) discard; gl_FragColor = vec4(vColor, 0.2 * alphaMask); }`,
+          transparent: true,
+          depthWrite: false,
+          blending: THREE4__namespace.AdditiveBlending
+        });
+        const polyLines = new THREE4__namespace.LineSegments(polyGeo, polyMat);
+        polyLines.frustumCulled = false;
+        root.add(polyLines);
+      }
+    }
     resize();
   }
   let lastData = void 0;
   let lastAdapter = void 0;
   let lastModel = void 0;
+  let lastAppliedLon = void 0;
+  let lastAppliedLat = void 0;
   function setConfig(cfg) {
     currentConfig = cfg;
+    if (typeof cfg.camera?.lon === "number" && cfg.camera.lon !== lastAppliedLon) {
+      state.lon = cfg.camera.lon;
+      state.targetLon = cfg.camera.lon;
+      lastAppliedLon = cfg.camera.lon;
+    }
+    if (typeof cfg.camera?.lat === "number" && cfg.camera.lat !== lastAppliedLat) {
+      state.lat = cfg.camera.lat;
+      state.targetLat = cfg.camera.lat;
+      lastAppliedLat = cfg.camera.lat;
+    }
     let shouldRebuild = false;
     let model = cfg.model;
     if (!model && cfg.data && cfg.adapter) {
@@ -993,22 +1158,21 @@ function createEngine({
   function getFullArrangement() {
     const arr = {};
     if (starPoints && starPoints.geometry.attributes.position) {
-      const positions = starPoints.geometry.attributes.position.array;
+      const attr = starPoints.geometry.attributes.position;
       for (let i = 0; i < starIndexToId.length; i++) {
         const id = starIndexToId[i];
         if (id) {
-          const x = positions[i * 3] ?? 0;
-          const y = positions[i * 3 + 1] ?? 0;
-          const z = positions[i * 3 + 2] ?? 0;
-          if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)) {
-            arr[id] = { position: [x, y, z] };
-          }
+          const x = attr.getX(i);
+          const y = attr.getY(i);
+          const z = attr.getZ(i);
+          arr[id] = { position: [x, y, z] };
         }
       }
     }
     for (const item of dynamicLabels) {
       arr[item.node.id] = { position: [item.obj.position.x, item.obj.position.y, item.obj.position.z] };
     }
+    Object.assign(arr, state.tempArrangement);
     return arr;
   }
   function pick(ev) {
@@ -1094,6 +1258,7 @@ function createEngine({
     state.isDragging = true;
     state.velocityX = 0;
     state.velocityY = 0;
+    state.tempArrangement = {};
     document.body.style.cursor = "grabbing";
   }
   function onMouseMove(e) {
@@ -1114,7 +1279,10 @@ function createEngine({
       } else if (state.draggedGroup && state.draggedNodeId) {
         const group = state.draggedGroup;
         const item = dynamicLabels.find((l) => l.node.id === state.draggedNodeId);
-        if (item) item.obj.position.copy(newPos);
+        if (item) {
+          item.obj.position.copy(newPos);
+          state.tempArrangement[item.node.id] = { position: [newPos.x, newPos.y, newPos.z] };
+        }
         const vStart = group.labelInitialPos.clone().normalize();
         const vEnd = newPos.clone().normalize();
         const q = new THREE4__namespace.Quaternion().setFromUnitVectors(vStart, vEnd);
@@ -1124,6 +1292,10 @@ function createEngine({
           for (const child of group.children) {
             tempVec.copy(child.initialPos).applyQuaternion(q);
             attr.setXYZ(child.index, tempVec.x, tempVec.y, tempVec.z);
+            const id = starIndexToId[child.index];
+            if (id) {
+              state.tempArrangement[id] = { position: [tempVec.x, tempVec.y, tempVec.z] };
+            }
           }
           attr.needsUpdate = true;
         }
@@ -1143,6 +1315,26 @@ function createEngine({
       state.lat = state.targetLat;
     } else {
       const hit = pick(e);
+      if (hit && hit.type === "star") {
+        if (currentHoverNodeId !== hit.node.id) {
+          currentHoverNodeId = hit.node.id;
+          const res = createTextTexture(hit.node.label, "#ffd700");
+          if (res) {
+            hoverLabelMat.uniforms.uMap.value = res.tex;
+            const baseScale = 0.03;
+            const size = new THREE4__namespace.Vector2(baseScale * res.aspect, baseScale);
+            hoverLabelMat.uniforms.uSize.value = size;
+            hoverLabelMesh.scale.set(size.x, size.y, 1);
+          }
+        }
+        hoverLabelMesh.position.copy(hit.point);
+        hoverLabelMat.uniforms.uAlpha.value = 1;
+        hoverLabelMesh.visible = true;
+      } else {
+        currentHoverNodeId = null;
+        hoverLabelMat.uniforms.uAlpha.value = 0;
+        hoverLabelMesh.visible = false;
+      }
       if (hit?.node.id !== handlers._lastHoverId) {
         handlers._lastHoverId = hit?.node.id;
         handlers.onHover?.(hit?.node);
@@ -1284,30 +1476,107 @@ function createEngine({
     camera.up.normalize();
     camera.lookAt(target);
     updateUniforms();
-    const cameraDir = new THREE4__namespace.Vector3();
-    camera.getWorldDirection(cameraDir);
-    const objPos = new THREE4__namespace.Vector3();
-    const objDir = new THREE4__namespace.Vector3();
-    const SHOW_LABELS_FOV = 60;
+    const DIVISION_THRESHOLD = 60;
+    const showDivisions = state.fov > DIVISION_THRESHOLD;
+    if (constellationLines) {
+      constellationLines.visible = currentConfig?.showConstellationLines ?? false;
+    }
+    if (boundaryLines) {
+      boundaryLines.visible = currentConfig?.showDivisionBoundaries ?? false;
+    }
+    const rect = renderer.domElement.getBoundingClientRect();
+    const screenW = rect.width;
+    const screenH = rect.height;
+    const aspect = screenW / screenH;
+    const labelsToCheck = [];
+    const occupied = [];
+    function isOverlapping(x2, y2, w, h) {
+      for (const r2 of occupied) {
+        if (x2 < r2.x + r2.w && x2 + w > r2.x && y2 < r2.y + r2.h && y2 + h > r2.y) return true;
+      }
+      return false;
+    }
+    const showBookLabels = currentConfig?.showBookLabels === true;
+    const showDivisionLabels = currentConfig?.showDivisionLabels === true;
+    const showChapterLabels = currentConfig?.showChapterLabels === true;
+    const showChapters = state.fov < 35;
     for (const item of dynamicLabels) {
       const uniforms = item.obj.material.uniforms;
-      let targetAlpha = 0;
-      if (state.fov < SHOW_LABELS_FOV) {
-        item.obj.getWorldPosition(objPos);
-        objDir.subVectors(objPos, camera.position).normalize();
-        const dot = cameraDir.dot(objDir);
-        const fullVisibleDot = 0.98;
-        const invisibleDot = 0.9;
-        let gazeOpacity = 0;
-        if (dot >= fullVisibleDot) gazeOpacity = 1;
-        else if (dot > invisibleDot) gazeOpacity = (dot - invisibleDot) / (fullVisibleDot - invisibleDot);
-        const zoomFactor = 1 - THREE4__namespace.MathUtils.smoothstep(40, SHOW_LABELS_FOV, state.fov);
-        targetAlpha = gazeOpacity * zoomFactor;
-      }
-      if (uniforms.uAlpha) {
-        uniforms.uAlpha.value = THREE4__namespace.MathUtils.lerp(uniforms.uAlpha.value, targetAlpha, 0.1);
+      const level = item.node.level;
+      let isEnabled = false;
+      if (level === 2 && showBookLabels) isEnabled = true;
+      else if (level === 1 && showDivisionLabels) isEnabled = true;
+      else if (level === 3 && showChapterLabels) isEnabled = true;
+      if (!isEnabled) {
+        uniforms.uAlpha.value = THREE4__namespace.MathUtils.lerp(uniforms.uAlpha.value, 0, 0.2);
         item.obj.visible = uniforms.uAlpha.value > 0.01;
+        continue;
       }
+      const pWorld = item.obj.position;
+      const pProj = smartProjectJS(pWorld);
+      if (pProj.z > 0.2) {
+        uniforms.uAlpha.value = THREE4__namespace.MathUtils.lerp(uniforms.uAlpha.value, 0, 0.2);
+        item.obj.visible = uniforms.uAlpha.value > 0.01;
+        continue;
+      }
+      if (level === 3 && !showChapters && item.node.id !== state.draggedNodeId) {
+        uniforms.uAlpha.value = THREE4__namespace.MathUtils.lerp(uniforms.uAlpha.value, 0, 0.2);
+        item.obj.visible = uniforms.uAlpha.value > 0.01;
+        continue;
+      }
+      const ndcX = pProj.x * globalUniforms.uScale.value / aspect;
+      const ndcY = pProj.y * globalUniforms.uScale.value;
+      const sX = (ndcX * 0.5 + 0.5) * screenW;
+      const sY = (-ndcY * 0.5 + 0.5) * screenH;
+      const size = uniforms.uSize.value;
+      const pixelH = size.y * screenH * 0.8;
+      const pixelW = size.x * screenH * 0.8;
+      labelsToCheck.push({ item, sX, sY, w: pixelW, h: pixelH, uniforms, level });
+    }
+    const hoverId = handlers._lastHoverId;
+    const selectedId = state.draggedNodeId;
+    labelsToCheck.sort((a, b) => {
+      const getScore = (l) => {
+        if (l.item.node.id === selectedId) return 10;
+        if (l.item.node.id === hoverId) return 9;
+        const level = l.level;
+        if (level === 2) return 5;
+        if (level === 1) return showDivisions ? 6 : 1;
+        return 0;
+      };
+      return getScore(b) - getScore(a);
+    });
+    for (const l of labelsToCheck) {
+      let target2 = 0;
+      const isSpecial = l.item.node.id === selectedId || l.item.node.id === hoverId;
+      if (l.level === 1) {
+        let rot = 0;
+        const blend = globalUniforms.uBlend.value;
+        if (blend > 0.5) {
+          const dx = l.sX - screenW / 2;
+          const dy = l.sY - screenH / 2;
+          rot = Math.atan2(-dy, -dx) - Math.PI / 2;
+        }
+        l.uniforms.uAngle.value = THREE4__namespace.MathUtils.lerp(l.uniforms.uAngle.value, rot, 0.1);
+      }
+      if (l.level === 2) {
+        target2 = 1;
+        occupied.push({ x: l.sX - l.w / 2, y: l.sY - l.h / 2, w: l.w, h: l.h });
+      } else if (l.level === 1) {
+        if (showDivisions || isSpecial) {
+          const pad = -5;
+          if (!isOverlapping(l.sX - l.w / 2 - pad, l.sY - l.h / 2 - pad, l.w + pad * 2, l.h + pad * 2)) {
+            target2 = 1;
+            occupied.push({ x: l.sX - l.w / 2, y: l.sY - l.h / 2, w: l.w, h: l.h });
+          }
+        }
+      } else if (l.level === 3) {
+        if (showChapters || isSpecial) {
+          target2 = 1;
+        }
+      }
+      l.uniforms.uAlpha.value = THREE4__namespace.MathUtils.lerp(l.uniforms.uAlpha.value, target2, 0.1);
+      l.item.obj.visible = l.uniforms.uAlpha.value > 0.01;
     }
     renderer.render(scene, camera);
   }
@@ -1392,6 +1661,7 @@ var StarMap = react.forwardRef(
 function bibleToSceneModel(data) {
   const nodes = [];
   const links = [];
+  let bookCounter = 0;
   const id = {
     testament: (t) => `T:${t}`,
     division: (t, d) => `D:${t}:${d}`,
@@ -1412,10 +1682,12 @@ function bibleToSceneModel(data) {
       });
       links.push({ source: did, target: tid });
       for (const b of d.books) {
+        bookCounter++;
+        const bookLabel = `${bookCounter}. ${b.name}`;
         const bid = id.book(b.key);
         nodes.push({
           id: bid,
-          label: b.name,
+          label: bookLabel,
           level: 2,
           parent: did,
           meta: { testament: t.name, division: d.name, bookKey: b.key, book: b.name }
@@ -1427,7 +1699,7 @@ function bibleToSceneModel(data) {
           const cid = id.chapter(b.key, chapterNum);
           nodes.push({
             id: cid,
-            label: `${b.name} ${chapterNum}`,
+            label: `${bookLabel} ${chapterNum}`,
             level: 3,
             parent: bid,
             weight: verseCounts[i],
@@ -30490,9 +30762,149 @@ var default_stars_default = {
     }
   ]
 };
+var defaultGenerateOptions = {
+  seed: 12345,
+  discRadius: 2e3,
+  milkyWayEnabled: true,
+  milkyWayAngle: 60,
+  milkyWayWidth: 0.3,
+  // Width in dot-product space
+  milkyWayStrength: 0.7,
+  noiseScale: 2,
+  noiseStrength: 0.4,
+  clusterSpread: 0.08
+  // Radians approx
+};
+var RNG = class {
+  seed;
+  constructor(seed) {
+    this.seed = seed;
+  }
+  // Returns 0..1
+  next() {
+    this.seed = (this.seed * 9301 + 49297) % 233280;
+    return this.seed / 233280;
+  }
+  // Returns range [min, max)
+  range(min, max) {
+    return min + this.next() * (max - min);
+  }
+  // Uniform random on upper hemisphere (y > 0)
+  randomOnSphere() {
+    const y = this.next();
+    const theta = 2 * Math.PI * this.next();
+    const r = Math.sqrt(1 - y * y);
+    const x = r * Math.cos(theta);
+    const z = r * Math.sin(theta);
+    return new THREE4__namespace.Vector3(x, y, z);
+  }
+};
+function simpleNoise3D(v, scale) {
+  const s = scale;
+  return (Math.sin(v.x * s) + Math.sin(v.y * s * 1.3) + Math.sin(v.z * s * 1.7) + Math.sin(v.x * s * 2.1 + v.y * s * 2.1) * 0.5) / 3.5;
+}
+function getDensity(v, opts, mwNormal) {
+  let density = 0.3;
+  if (opts.milkyWayEnabled) {
+    const dot = v.dot(mwNormal);
+    const dist = Math.abs(dot);
+    const band = Math.exp(-(dist * dist) / (opts.milkyWayWidth * opts.milkyWayWidth));
+    density += band * opts.milkyWayStrength;
+  }
+  const noise = simpleNoise3D(v, opts.noiseScale);
+  density *= 1 + noise * opts.noiseStrength;
+  return Math.max(0.01, density);
+}
+function generateArrangement(bible, options = {}) {
+  const opts = { ...defaultGenerateOptions, ...options };
+  const rng = new RNG(opts.seed);
+  const arrangement = {};
+  const books = [];
+  bible.testaments.forEach((t) => {
+    t.divisions.forEach((d) => {
+      d.books.forEach((b) => {
+        books.push({
+          key: b.key,
+          name: b.name,
+          chapters: b.chapters,
+          division: d.name,
+          testament: t.name
+        });
+      });
+    });
+  });
+  const bookCount = books.length;
+  const mwRad = THREE4__namespace.MathUtils.degToRad(opts.milkyWayAngle);
+  const mwNormal = new THREE4__namespace.Vector3(Math.sin(mwRad), Math.cos(mwRad), 0).normalize();
+  const anchors = [];
+  for (let i = 0; i < bookCount; i++) {
+    let bestP = new THREE4__namespace.Vector3();
+    let valid = false;
+    let attempt = 0;
+    while (!valid && attempt < 100) {
+      const p = rng.randomOnSphere();
+      const d = getDensity(p, opts, mwNormal);
+      if (rng.next() < d) {
+        bestP = p;
+        valid = true;
+      }
+      attempt++;
+    }
+    if (!valid) bestP = rng.randomOnSphere();
+    anchors.push(bestP);
+  }
+  anchors.sort((a, b) => {
+    const lonA = Math.atan2(a.z, a.x);
+    const lonB = Math.atan2(b.z, b.x);
+    return lonA - lonB;
+  });
+  books.forEach((book, i) => {
+    const anchor = anchors[i];
+    const anchorPos = anchor.clone().multiplyScalar(opts.discRadius);
+    arrangement[`B:${book.key}`] = { position: [anchorPos.x, anchorPos.y, anchorPos.z] };
+    for (let c = 0; c < book.chapters; c++) {
+      const localSpread = opts.clusterSpread * (0.8 + rng.next() * 0.4);
+      const offset = new THREE4__namespace.Vector3(
+        (rng.next() - 0.5) * 2,
+        (rng.next() - 0.5) * 2,
+        (rng.next() - 0.5) * 2
+      ).normalize().multiplyScalar(rng.next() * localSpread);
+      const starDir = anchor.clone().add(offset).normalize();
+      if (starDir.y < 0.01) {
+        starDir.y = 0.01;
+        starDir.normalize();
+      }
+      const starPos = starDir.multiplyScalar(opts.discRadius);
+      const chapId = `C:${book.key}:${c + 1}`;
+      arrangement[chapId] = { position: [starPos.x, starPos.y, starPos.z] };
+    }
+  });
+  const divisions = /* @__PURE__ */ new Map();
+  books.forEach((book, i) => {
+    const anchor = anchors[i];
+    const anchorPos = anchor.clone().multiplyScalar(opts.discRadius);
+    const divId = `D:${book.testament}:${book.division}`;
+    if (!divisions.has(divId)) {
+      divisions.set(divId, { sum: new THREE4__namespace.Vector3(), count: 0 });
+    }
+    const entry = divisions.get(divId);
+    entry.sum.add(anchorPos);
+    entry.count++;
+  });
+  divisions.forEach((val, key) => {
+    if (val.count > 0) {
+      val.sum.divideScalar(val.count);
+      val.sum.normalize().multiplyScalar(opts.discRadius * 0.9);
+      arrangement[key] = { position: [val.sum.x, val.sum.y, val.sum.z] };
+    }
+  });
+  return arrangement;
+}
 
 exports.StarMap = StarMap;
 exports.bibleToSceneModel = bibleToSceneModel;
+exports.defaultGenerateOptions = defaultGenerateOptions;
 exports.defaultStars = default_stars_default;
+exports.generateArrangement = generateArrangement;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map