spoint 0.1.586 → 0.1.588

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.586",
+  "version": "0.1.588",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "workspaces": [

package/src/terrain/CaveSDF.js

@@ -0,0 +1,92 @@
+import { marchRockSurface } from './RockShapes.js'
+
+export function makeSphereCaveSDF(cx, cy, cz, radius) {
+  return (x, y, z) => {
+    const dx = x - cx, dy = y - cy, dz = z - cz
+    return Math.sqrt(dx * dx + dy * dy + dz * dz) - radius
+  }
+}
+
+export function polygonizeCaveSDF(sdf, res = 24) {
+  return marchRockSurface(res, sdf)
+}
+
+export function createCaveVolume(worldX, worldY, worldZ, worldRadius) {
+  const sdf = makeSphereCaveSDF(0, 0, 0, 1)
+  const localToWorld = (lx, ly, lz) => [worldX + lx * worldRadius, worldY + ly * worldRadius, worldZ + lz * worldRadius]
+  const worldToLocal = (wx, wy, wz) => [(wx - worldX) / worldRadius, (wy - worldY) / worldRadius, (wz - worldZ) / worldRadius]
+  const worldSDF = (wx, wy, wz) => {
+    const [lx, ly, lz] = worldToLocal(wx, wy, wz)
+    return sdf(lx, ly, lz) * worldRadius
+  }
+  return { sdf: worldSDF, localToWorld, worldToLocal, worldX, worldY, worldZ, worldRadius }
+}
+
+export function polygonizeCaveVolume(caveVolume, res = 24) {
+  const local = polygonizeCaveSDF((lx, ly, lz) => makeSphereCaveSDF(0, 0, 0, 1)(lx, ly, lz), res)
+  const positions = new Float32Array(local.positions.length)
+  for (let v = 0; v < local.vc; v++) {
+    const [wx, wy, wz] = caveVolume.localToWorld(local.positions[v * 3], local.positions[v * 3 + 1], local.positions[v * 3 + 2])
+    positions[v * 3] = wx
+    positions[v * 3 + 1] = wy
+    positions[v * 3 + 2] = wz
+  }
+  return { positions: positions.subarray(0, local.vc * 3), vc: local.vc, indices: local.indices, ic: local.ic }
+}
+
+export function createCaveCarveLayer() {
+  const volumes = []
+
+  function addSphereCave(worldX, worldY, worldZ, worldRadius) {
+    if (!Number.isFinite(worldX) || !Number.isFinite(worldY) || !Number.isFinite(worldZ)) return { added: false }
+    if (!Number.isFinite(worldRadius) || worldRadius <= 0) return { added: false }
+    volumes.push(createCaveVolume(worldX, worldY, worldZ, worldRadius))
+    return { added: true, count: volumes.length }
+  }
+
+  function heightDeltaAt(x, z, surfaceY) {
+    if (volumes.length === 0) return 0
+    let delta = 0
+    for (const vol of volumes) {
+      const dx = x - vol.worldX, dz = z - vol.worldZ
+      const horizontalDist = Math.hypot(dx, dz)
+      if (horizontalDist > vol.worldRadius) continue
+      const verticalSpan = Math.sqrt(Math.max(0, vol.worldRadius * vol.worldRadius - horizontalDist * horizontalDist))
+      const caveTop = vol.worldY + verticalSpan
+      if (caveTop < surfaceY) continue
+      delta -= (caveTop - surfaceY) + verticalSpan
+    }
+    return delta
+  }
+
+  function wrapHeightFn(baseHeightFn) {
+    if (typeof baseHeightFn !== 'function') return baseHeightFn
+    return function caveWrappedHeightFn(x, z) {
+      const base = baseHeightFn(x, z)
+      if (!Number.isFinite(base)) return base
+      return base + heightDeltaAt(x, z, base)
+    }
+  }
+
+  function toJSON() {
+    return { version: 1, volumes: volumes.map(v => ({ worldX: v.worldX, worldY: v.worldY, worldZ: v.worldZ, worldRadius: v.worldRadius })) }
+  }
+
+  function clear() { volumes.length = 0 }
+
+  return {
+    addSphereCave, heightDeltaAt, wrapHeightFn, toJSON, clear,
+    get volumeCount() { return volumes.length },
+  }
+}
+
+export function loadCaveCarveLayer(json) {
+  const layer = createCaveCarveLayer()
+  if (json && Array.isArray(json.volumes)) {
+    for (const v of json.volumes) {
+      if (!v || !Number.isFinite(v.worldX) || !Number.isFinite(v.worldY) || !Number.isFinite(v.worldZ) || !Number.isFinite(v.worldRadius)) continue
+      layer.addSphereCave(v.worldX, v.worldY, v.worldZ, v.worldRadius)
+    }
+  }
+  return layer
+}

package/src/terrain/TerrainPhysics.js

@@ -6,6 +6,7 @@ import { createCachedAnchorField } from './ClimateCache.js'
 import { createHeightDelta, loadHeightDelta } from './HeightDelta.js'
 import { createBiomeOverride, loadBiomeOverride } from './BiomeOverride.js'
 import { loadSplineCarveLayer } from './SplineCarve.js'
+import { loadCaveCarveLayer } from './CaveSDF.js'
 
 const _now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now())
 
@@ -235,7 +236,7 @@ async function createGpuPatchHeightFn({ frame, tcfg, offsetY }) {
 // (re)build -- kept strictly separate from tcfg/seed (never merged into it) so seeds stay shareable.
 // biomeOverrideJSON (optional): a previously-serialized src/terrain/BiomeOverride.js toJSON() payload
 // (paint-biome strokes), same replay discipline as heightDeltaJSON.
-export async function setupTerrainStreaming({ physics, playerManager, worldDef, terrain, heightDeltaJSON, biomeOverrideJSON, splineCarveJSON }) {
+export async function setupTerrainStreaming({ physics, playerManager, worldDef, terrain, heightDeltaJSON, biomeOverrideJSON, splineCarveJSON, caveCarveJSON }) {
   // accepts either the terrain app's merged tcfg directly, or legacy worldDef.terrain.
   const tcfg = terrain || (worldDef && worldDef.terrain) || null
   if (!tcfg || tcfg.enabled === false || !physics || typeof physics.addHeightField !== 'function') return null
@@ -285,7 +286,8 @@ export async function setupTerrainStreaming({ physics, playerManager, worldDef,
   // stays byte-identical, sculpting is purely an on-top layer. heightDeltaJSON (if any) replays prior
   // strokes so a rebuild (reseed/streamer restart) keeps existing sculpting intact.
   const heightDelta = loadHeightDelta(heightDeltaJSON, baseHeightFn)
-  const heightFn = splineCarve.wrapHeightFn(heightDelta.wrapHeightFn(baseHeightFn))
+  const caveCarve = loadCaveCarveLayer(caveCarveJSON)
+  const heightFn = caveCarve.wrapHeightFn(splineCarve.wrapHeightFn(heightDelta.wrapHeightFn(baseHeightFn)))
   const getCenter = () => {
     let sx = 0, sz = 0, n = 0
     const players = playerManager && playerManager.players
@@ -362,6 +364,7 @@ export async function setupTerrainStreaming({ physics, playerManager, worldDef,
   // keep serving pre-paint species/density for already-visited territory.
   streamer.biomeOverride = biomeOverride
   streamer.splineCarve = splineCarve
+  streamer.caveCarve = caveCarve
   streamer.repaintBiome = async function repaintBiome() {
     // Re-cook the FULL current multi-player ring (not just one point) so every connected player's
     // territory picks up the repaint, matching this row's "around each player" streaming policy.