spoint 0.1.80 → 0.1.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "main": "src/index.js",

package/src/apps/AppRuntime.js

@@ -64,7 +64,7 @@ export class AppRuntime {
     }
     if (config.autoTrimesh && entity.model && this._physics) {
       entity.collider = { type: 'trimesh', model: entity.model }
-      this._physics.addStaticTrimeshAsync(this.resolveAssetPath(entity.model), 0)
+      this._physics.addStaticTrimeshAsync(this.resolveAssetPath(entity.model), 0, entity.position || [0,0,0])
         .then(id => { entity._physicsBodyId = id })
         .catch(e => console.error(`[AppRuntime] Failed to create trimesh for ${entity.model}:`, e.message))
     }

package/src/physics/GLBLoader.js

@@ -364,6 +364,164 @@ async function extractMeshWithMeshopt(buf, json, prim, binOffset, meshName) {
   }
 }
 
+/**
+ * Extract ALL meshes and ALL primitives from a GLB file and combine them into
+ * a single flat vertex/index buffer suitable for a trimesh collider.
+ * Handles Draco-compressed primitives. Used for map collision where the GLB
+ * may have dozens of meshes each with many primitives.
+ *
+ * @param {string} filepath - Path to GLB file
+ * @returns {Promise<Object>} {vertices: Float32Array, indices: Uint32Array, vertexCount, triangleCount}
+ */
+export async function extractAllMeshesFromGLBAsync(filepath) {
+  console.log(`[GLBLoader] Extracting ALL meshes from: ${filepath}`)
+  const buf = readFileSync(filepath)
+  if (buf.toString('ascii', 0, 4) !== 'glTF') throw new Error('Not a GLB file')
+
+  const jsonLen = buf.readUInt32LE(12)
+  const json = JSON.parse(buf.toString('utf-8', 20, 20 + jsonLen))
+  const binOffset = 20 + jsonLen + 8
+
+  const allVertices = []
+  const allIndices = []
+  let vertexOffset = 0
+  let totalTriangles = 0
+
+  // Build a node->transform map for node hierarchy
+  const nodeTransforms = buildNodeTransforms(json)
+
+  for (let meshIdx = 0; meshIdx < (json.meshes || []).length; meshIdx++) {
+    const mesh = json.meshes[meshIdx]
+    // Find node referencing this mesh to get its world transform
+    const nodeIdx = (json.nodes || []).findIndex(n => n.mesh === meshIdx)
+    const worldTransform = nodeIdx >= 0 ? nodeTransforms[nodeIdx] : null
+
+    for (let primIdx = 0; primIdx < mesh.primitives.length; primIdx++) {
+      const prim = mesh.primitives[primIdx]
+      let result
+      try {
+        if (prim.extensions?.KHR_draco_mesh_compression) {
+          result = await decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+        } else {
+          result = extractStandardMesh(buf, json, prim, binOffset, mesh.name)
+        }
+      } catch (e) {
+        console.warn(`[GLBLoader] Skipping mesh[${meshIdx}] prim[${primIdx}]: ${e.message}`)
+        continue
+      }
+
+      if (!result.indices || result.triangleCount === 0) continue
+
+      // Apply world transform to vertices if present
+      let verts = result.vertices
+      if (worldTransform) {
+        verts = applyTransformMatrix(result.vertices, worldTransform)
+      }
+
+      allVertices.push(verts)
+      // Remap indices by current vertex offset
+      const remapped = new Uint32Array(result.indices.length)
+      for (let i = 0; i < result.indices.length; i++) {
+        remapped[i] = result.indices[i] + vertexOffset
+      }
+      allIndices.push(remapped)
+      vertexOffset += result.vertexCount
+      totalTriangles += result.triangleCount
+    }
+  }
+
+  if (allVertices.length === 0) throw new Error('No valid mesh primitives found in GLB')
+
+  // Concatenate all vertex and index arrays
+  const totalVerts = vertexOffset
+  const combinedVertices = new Float32Array(totalVerts * 3)
+  let vOff = 0
+  for (const v of allVertices) { combinedVertices.set(v, vOff); vOff += v.length }
+
+  const combinedIndices = new Uint32Array(totalTriangles * 3)
+  let iOff = 0
+  for (const idx of allIndices) { combinedIndices.set(idx, iOff); iOff += idx.length }
+
+  console.log(`[GLBLoader] Combined: ${totalVerts} vertices, ${totalTriangles} triangles from ${allIndices.length} primitives`)
+  return { vertices: combinedVertices, indices: combinedIndices, vertexCount: totalVerts, triangleCount: totalTriangles }
+}
+
+/**
+ * Build world-space 4x4 transform matrices for every node in the scene graph.
+ * Returns an array indexed by node index.
+ */
+function buildNodeTransforms(json) {
+  const nodes = json.nodes || []
+  const matrices = new Array(nodes.length).fill(null)
+
+  function getMatrix(nodeIdx) {
+    if (matrices[nodeIdx] !== null) return matrices[nodeIdx]
+    const node = nodes[nodeIdx]
+    let local = mat4Identity()
+    if (node.matrix) {
+      local = node.matrix.slice()
+    } else {
+      const t = node.translation || [0, 0, 0]
+      const r = node.rotation || [0, 0, 0, 1]
+      const s = node.scale || [1, 1, 1]
+      local = mat4TRS(t, r, s)
+    }
+    // Find parent
+    const parentIdx = nodes.findIndex((n, i) => i !== nodeIdx && (n.children || []).includes(nodeIdx))
+    if (parentIdx >= 0) {
+      local = mat4Mul(getMatrix(parentIdx), local)
+    }
+    matrices[nodeIdx] = local
+    return local
+  }
+
+  for (let i = 0; i < nodes.length; i++) getMatrix(i)
+  return matrices
+}
+
+function mat4Identity() {
+  return [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
+}
+
+function mat4TRS(t, r, s) {
+  const [qx, qy, qz, qw] = r
+  const [sx, sy, sz] = s
+  const x2=qx+qx, y2=qy+qy, z2=qz+qz
+  const xx=qx*x2, xy=qx*y2, xz=qx*z2
+  const yy=qy*y2, yz=qy*z2, zz=qz*z2
+  const wx=qw*x2, wy=qw*y2, wz=qw*z2
+  return [
+    (1-(yy+zz))*sx, (xy+wz)*sx,    (xz-wy)*sx,    0,
+    (xy-wz)*sy,     (1-(xx+zz))*sy,(yz+wx)*sy,    0,
+    (xz+wy)*sz,     (yz-wx)*sz,    (1-(xx+yy))*sz,0,
+    t[0], t[1], t[2], 1
+  ]
+}
+
+function mat4Mul(a, b) {
+  const out = new Array(16)
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      let sum = 0
+      for (let k = 0; k < 4; k++) sum += a[row + k*4] * b[k + col*4]
+      out[row + col*4] = sum
+    }
+  }
+  return out
+}
+
+function applyTransformMatrix(vertices, m) {
+  const count = vertices.length / 3
+  const out = new Float32Array(vertices.length)
+  for (let i = 0; i < count; i++) {
+    const x = vertices[i*3], y = vertices[i*3+1], z = vertices[i*3+2]
+    out[i*3]   = m[0]*x + m[4]*y + m[8]*z  + m[12]
+    out[i*3+1] = m[1]*x + m[5]*y + m[9]*z  + m[13]
+    out[i*3+2] = m[2]*x + m[6]*y + m[10]*z + m[14]
+  }
+  return out
+}
+
 /**
  * Check if a GLB file has Draco-compressed meshes without attempting extraction.
  * Useful for validation and error reporting.

package/src/physics/World.js

@@ -1,5 +1,5 @@
-import initJolt from 'jolt-physics/wasm-compat'
-import { extractMeshFromGLB, extractMeshFromGLBAsync } from './GLBLoader.js'
+import initJolt from 'jolt-physics/wasm-compat'
+import { extractMeshFromGLB, extractMeshFromGLBAsync, extractAllMeshesFromGLBAsync } from './GLBLoader.js'
 const LAYER_STATIC = 0, LAYER_DYNAMIC = 1, NUM_LAYERS = 2
 let joltInstance = null
 async function getJolt() { if (!joltInstance) joltInstance = await initJolt(); return joltInstance }
@@ -71,110 +71,92 @@ export class PhysicsWorld {
     layer = motionType === 'static' ? LAYER_STATIC : LAYER_DYNAMIC
     return this._addBody(shape, position, mt, layer, { ...opts, meta: { type: motionType, shape: shapeType } })
   }
-  addStaticTrimesh(glbPath, meshIndex = 0) {
-    const J = this.Jolt
-    const mesh = extractMeshFromGLB(glbPath, meshIndex)
-    
-    // Apply node transform if present (scale, rotation, translation)
-    let vertices = mesh.vertices
-    const nodeT = mesh.nodeTransform
-    if (nodeT) {
-      const numVerts = mesh.vertexCount
-      vertices = new Float32Array(numVerts * 3)
-      
-      const scale = nodeT.scale || [1, 1, 1]
-      const translation = nodeT.translation || [0, 0, 0]
-      const rotation = nodeT.rotation
-      
-      for (let i = 0; i < numVerts; i++) {
-        let x = mesh.vertices[i * 3] * scale[0]
-        let y = mesh.vertices[i * 3 + 1] * scale[1]
-        let z = mesh.vertices[i * 3 + 2] * scale[2]
-        
-        if (rotation) {
-          const [qx, qy, qz, qw] = rotation
-          const ix = qw * x + qy * z - qz * y
-          const iy = qw * y + qz * x - qx * z
-          const iz = qw * z + qx * y - qy * x
-          const iw = -qx * x - qy * y - qz * z
-          x = ix * qw - iw * qx - iy * qz + iz * qy
-          y = iy * qw - iw * qy - iz * qx + ix * qz
-          z = iz * qw - iw * qz - ix * qy + iy * qx
-        }
-        
-        vertices[i * 3] = x + translation[0]
-        vertices[i * 3 + 1] = y + translation[1]
-        vertices[i * 3 + 2] = z + translation[2]
-      }
-    }
-    
-    const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
-    for (let t = 0; t < mesh.triangleCount; t++) {
-      const tri = triangles.at(t)
-      for (let v = 0; v < 3; v++) {
-        const idx = mesh.indices[t * 3 + v]
-        tri.set_mV(v, new J.Float3(vertices[idx * 3], vertices[idx * 3 + 1], vertices[idx * 3 + 2]))
-      }
-    }
-    const shape = new J.MeshShapeSettings(triangles).Create().Get()
-    return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
-  }
+  addStaticTrimesh(glbPath, meshIndex = 0) {
+    const J = this.Jolt
+    const mesh = extractMeshFromGLB(glbPath, meshIndex)
+    
+    // Apply node transform if present (scale, rotation, translation)
+    let vertices = mesh.vertices
+    const nodeT = mesh.nodeTransform
+    if (nodeT) {
+      const numVerts = mesh.vertexCount
+      vertices = new Float32Array(numVerts * 3)
+      
+      const scale = nodeT.scale || [1, 1, 1]
+      const translation = nodeT.translation || [0, 0, 0]
+      const rotation = nodeT.rotation
+      
+      for (let i = 0; i < numVerts; i++) {
+        let x = mesh.vertices[i * 3] * scale[0]
+        let y = mesh.vertices[i * 3 + 1] * scale[1]
+        let z = mesh.vertices[i * 3 + 2] * scale[2]
+        
+        if (rotation) {
+          const [qx, qy, qz, qw] = rotation
+          const ix = qw * x + qy * z - qz * y
+          const iy = qw * y + qz * x - qx * z
+          const iz = qw * z + qx * y - qy * x
+          const iw = -qx * x - qy * y - qz * z
+          x = ix * qw - iw * qx - iy * qz + iz * qy
+          y = iy * qw - iw * qy - iz * qx + ix * qz
+          z = iz * qw - iw * qz - ix * qy + iy * qx
+        }
+        
+        vertices[i * 3] = x + translation[0]
+        vertices[i * 3 + 1] = y + translation[1]
+        vertices[i * 3 + 2] = z + translation[2]
+      }
+    }
+    
+    const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
+    const f3 = new J.Float3(0, 0, 0)
+    for (let t = 0; t < mesh.triangleCount; t++) {
+      const tri = triangles.at(t)
+      for (let v = 0; v < 3; v++) {
+        const idx = mesh.indices[t * 3 + v]
+        f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+        tri.set_mV(v, f3)
+      }
+    }
+    const settings = new J.MeshShapeSettings(triangles)
+    const shape = settings.Create().Get()
+    J.destroy(f3)
+    J.destroy(triangles)
+    J.destroy(settings)
+    return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
+  }
 
-  addStaticTrimeshAsync(glbPath, meshIndex = 0, position = [0, 0, 0]) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const J = this.Jolt
-        const mesh = await extractMeshFromGLBAsync(glbPath, meshIndex)
-        
-        // Apply node transform if present (scale, rotation, translation)
-        let vertices = mesh.vertices
-        const nodeT = mesh.nodeTransform
-        if (nodeT) {
-          const numVerts = mesh.vertexCount
-          vertices = new Float32Array(numVerts * 3)
-          
-          const scale = nodeT.scale || [1, 1, 1]
-          const translation = nodeT.translation || [0, 0, 0]
-          const rotation = nodeT.rotation
-          
-          for (let i = 0; i < numVerts; i++) {
-            let x = mesh.vertices[i * 3] * scale[0]
-            let y = mesh.vertices[i * 3 + 1] * scale[1]
-            let z = mesh.vertices[i * 3 + 2] * scale[2]
-            
-            if (rotation) {
-              const [qx, qy, qz, qw] = rotation
-              const ix = qw * x + qy * z - qz * y
-              const iy = qw * y + qz * x - qx * z
-              const iz = qw * z + qx * y - qy * x
-              const iw = -qx * x - qy * y - qz * z
-              x = ix * qw - iw * qx - iy * qz + iz * qy
-              y = iy * qw - iw * qy - iz * qx + ix * qz
-              z = iz * qw - iw * qz - ix * qy + iy * qx
-            }
-            
-            vertices[i * 3] = x + translation[0]
-            vertices[i * 3 + 1] = y + translation[1]
-            vertices[i * 3 + 2] = z + translation[2]
-          }
-        }
-        
-        const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
-        for (let t = 0; t < mesh.triangleCount; t++) {
-          const tri = triangles.at(t)
-          for (let v = 0; v < 3; v++) {
-            const idx = mesh.indices[t * 3 + v]
-            tri.set_mV(v, new J.Float3(vertices[idx * 3], vertices[idx * 3 + 1], vertices[idx * 3 + 2]))
-          }
-        }
-        const shape = new J.MeshShapeSettings(triangles).Create().Get()
-        const id = this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
-        resolve(id)
-      } catch (e) {
-        reject(e)
-      }
-    })
-  }
+  addStaticTrimeshAsync(glbPath, meshIndex = 0, position = [0, 0, 0]) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const J = this.Jolt
+        // Use combined extraction: all meshes + all primitives (handles Draco, multi-mesh maps)
+        const mesh = await extractAllMeshesFromGLBAsync(glbPath)
+        const { vertices, indices, triangleCount } = mesh
+
+        const triangles = new J.TriangleList(); triangles.resize(triangleCount)
+        // Reuse a single Float3 to avoid WASM heap growth from per-vertex allocations
+        const f3 = new J.Float3(0, 0, 0)
+        for (let t = 0; t < triangleCount; t++) {
+          const tri = triangles.at(t)
+          for (let v = 0; v < 3; v++) {
+            const idx = indices[t * 3 + v]
+            f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+            tri.set_mV(v, f3)
+          }
+        }
+        const settings = new J.MeshShapeSettings(triangles)
+        const shape = settings.Create().Get()
+        J.destroy(f3)
+        J.destroy(triangles)
+        J.destroy(settings)
+        const id = this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', triangles: triangleCount } })
+        resolve(id)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
   addPlayerCharacter(radius, halfHeight, position, mass) {
     const J = this.Jolt
     const cvs = new J.CharacterVirtualSettings()
@@ -232,9 +214,7 @@ export class PhysicsWorld {
   getCharacterPosition(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
     const p = ch.GetPosition()
-    const r = [p.GetX(), p.GetY(), p.GetZ()]
-    this.Jolt.destroy(p)
-    return r
+    return [p.GetX(), p.GetY(), p.GetZ()]
   }
   getCharacterVelocity(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
@@ -320,8 +300,8 @@ export class PhysicsWorld {
     const dir = len > 0 ? [direction[0] / len, direction[1] / len, direction[2] / len] : direction
     const ray = new J.RRayCast(new J.RVec3(origin[0], origin[1], origin[2]), new J.Vec3(dir[0] * maxDistance, dir[1] * maxDistance, dir[2] * maxDistance))
     const rs = new J.RayCastSettings(), col = new J.CastRayClosestHitCollisionCollector()
-    const bp = new J.DefaultBroadPhaseLayerFilter(this._ovbp)
-    const ol = new J.DefaultObjectLayerFilter(this._objFilter)
+    const bp = new J.DefaultBroadPhaseLayerFilter(this.jolt.GetObjectVsBroadPhaseLayerFilter(), LAYER_DYNAMIC)
+    const ol = new J.DefaultObjectLayerFilter(this.jolt.GetObjectLayerPairFilter(), LAYER_DYNAMIC)
     const eb = excludeBodyId != null ? this._getBody(excludeBodyId) : null
     const bf = eb ? new J.IgnoreSingleBodyFilter(eb.GetID()) : new J.BodyFilter()
     const sf = new J.ShapeFilter()
@@ -335,13 +315,25 @@ export class PhysicsWorld {
     return result
   }
   destroy() {
+    if (!this.Jolt) return
+    const J = this.Jolt
     if (this.characters) {
-      for (const [id, ch] of this.characters) {
-        this.Jolt.destroy(ch)
-      }
+      for (const ch of this.characters.values()) J.destroy(ch)
       this.characters.clear()
     }
+    if (this._charFilters) {
+      J.destroy(this._charFilters.bp)
+      J.destroy(this._charFilters.ol)
+      J.destroy(this._charFilters.body)
+      J.destroy(this._charFilters.shape)
+      this._charFilters = null
+    }
+    if (this._charUpdateSettings) { J.destroy(this._charUpdateSettings); this._charUpdateSettings = null }
+    if (this._charGravity) { J.destroy(this._charGravity); this._charGravity = null }
     for (const [id] of this.bodies) this.removeBody(id)
-    if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null }
+    if (this._tmpVec3) { J.destroy(this._tmpVec3); this._tmpVec3 = null }
+    if (this._tmpRVec3) { J.destroy(this._tmpRVec3); this._tmpRVec3 = null }
+    if (this.jolt) { J.destroy(this.jolt); this.jolt = null }
+    this.physicsSystem = null; this.bodyInterface = null
   }
 }

package/src/sdk/TickHandler.js

@@ -102,8 +102,7 @@ export function createTickHandler(deps) {
           const entitySnap = appRuntime.getSnapshotForPlayer(pos, stageLoader.getActiveStage().spatial.relevanceRadius)
           const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
           if (isKeyframe || !playerEntityMaps.has(player.id)) {
-            const encoded = SnapshotEncoder.encode(combined)
-            const { entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
+            const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
             playerEntityMaps.set(player.id, entityMap)
             connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
           } else {