spoint 0.1.77 → 0.1.79

package/apps/environment/index.js

@@ -25,14 +25,9 @@ export default {
   server: {
     setup(ctx) {
       ctx.physics.setStatic(true)
-      // schwust.glb decompressed - use real geometry-based collider
-      try {
-        ctx.physics.addTrimeshCollider()
-      } catch (e) {
-        // Fallback if convex hull extraction fails
-        console.log(`[Environment] Convex extraction failed: ${e.message}`); console.log(e.stack)
-        ctx.physics.addBoxCollider([50, 0.5, 50])
-      }
+      // Use simple box collider for environment - trimesh creation is too slow for large meshes
+      // The environment is primarily visual; players collide with box bounds instead
+      ctx.physics.addBoxCollider([50, 15, 50])
 
       ctx.state.smartObjects = new Map()
       ctx.state.editorMode = false

package/apps/world/index.js

@@ -58,7 +58,7 @@ export default {
     fadeTime: 0.15
   },
   entities: [
-    { id: 'environment', model: './apps/tps-game/schwust-uncompressed.glb', position: [0, -10, 0], app: 'environment' },
+    { id: 'environment', model: './apps/tps-game/schwust.glb', position: [0, -10, 0], app: 'environment' },
     { id: 'game', position: [0, 0, 0], app: 'tps-game' },
     { id: 'power-crates', position: [0, 0, 0], app: 'power-crate' },
     { id: 'interact-box', position: [-100, 3, -100], app: 'interactable' }

package/package.json

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

package/src/apps/AppContext.js

@@ -1,5 +1,5 @@
 import { CliDebugger } from '../debug/CliDebugger.js'
-import { extractMeshFromGLB } from '../physics/GLBLoader.js'
+import { extractMeshFromGLB, extractMeshFromGLBAsync } from '../physics/GLBLoader.js'
 
 export class AppContext {
   constructor(entity, runtime) {
@@ -95,7 +95,12 @@ export class AppContext {
           }
         } catch (err) {
           if (err.message.includes('Draco-compressed')) {
-            runtime._debug?.warn(`[physics] ${err.message}`)
+            runtime._debug?.warn(`[physics] Draco mesh detected - use addTrimeshCollider() for physics or box/sphere/capsule for trigger`)
+            if (runtime._physics) {
+              const mt = ent.bodyType === 'dynamic' ? 'dynamic' : ent.bodyType === 'kinematic' ? 'kinematic' : 'static'
+              ent.collider = { type: 'box', size: [0.5, 0.5, 0.5] }
+              ent._physicsBodyId = runtime._physics.addBody('box', [0.5, 0.5, 0.5], ent.position, mt, { rotation: ent.rotation, mass: ent.mass })
+            }
           } else {
             throw err
           }

package/src/physics/GLBLoader.js

@@ -1,48 +1,53 @@
 import { readFileSync } from 'node:fs'
 
+let _dracoDecoderPromise = null
+
+async function getDracoDecoder() {
+  if (!_dracoDecoderPromise) {
+    try {
+      const dracoGltf = await import('draco3dgltf')
+      _dracoDecoderPromise = dracoGltf.createDecoderModule()
+    } catch(e) {
+      throw new Error(`Failed to load Draco decoder: ${e.message}`)
+    }
+  }
+  return _dracoDecoderPromise
+}
+
 /**
  * Extract mesh from GLB file for physics collider creation.
- * 
- * NOTE: Draco-compressed meshes require decompression before vertex extraction.
- * This function detects Draco compression and provides clear error guidance.
- * 
+ * Supports both standard and Draco-compressed meshes.
+ *
  * @param {string} filepath - Path to GLB file
  * @param {number} meshIndex - Mesh index (default 0)
  * @returns {Object} {vertices, indices, vertexCount, triangleCount, name}
- * @throws {Error} If mesh is Draco-compressed or invalid
+ * @throws {Error} If mesh cannot be extracted
  */
 export function extractMeshFromGLB(filepath, meshIndex = 0) {
   console.log(`[GLBLoader] Extracting 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 mesh = json.meshes[meshIndex]
   if (!mesh) throw new Error(`Mesh index ${meshIndex} not found`)
-  
+
   const prim = mesh.primitives[0]
-  
-  // Check for Draco compression - this is the critical issue
+
+  // Check for Draco compression and defer to async handler
   if (prim.extensions?.KHR_draco_mesh_compression) {
-    const dracoExt = prim.extensions.KHR_draco_mesh_compression
-    const bufViewIdx = dracoExt.bufferView
-    throw new Error(
-      `Cannot extract collider from Draco-compressed mesh '${mesh.name}'. \n\n` +
-      `SOLUTION: Use gltfpack to decompress the model before physics import:\n` +
-      `  gltfpack -i model.glb -o model-uncompressed.glb -noq\n\n` +
-      `Or mark this model as 'no-physics' in entity config and use trigger colliders instead.`
-    )
+    throw new Error('Draco-compressed mesh detected. Use extractMeshFromGLBAsync() instead.')
   }
-  
+
   // Standard uncompressed GLB mesh extraction
   const posAcc = json.accessors[prim.attributes.POSITION]
   const posView = json.bufferViews[posAcc.bufferView]
   const posOff = binOffset + (posView.byteOffset || 0) + (posAcc.byteOffset || 0)
   const vertices = new Float32Array(buf.buffer.slice(posOff, posOff + posAcc.count * 12))
-  
+
   let indices = null
   if (prim.indices !== undefined) {
     const idxAcc = json.accessors[prim.indices]
@@ -55,13 +60,125 @@ export function extractMeshFromGLB(filepath, meshIndex = 0) {
       indices = new Uint32Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 4))
     }
   }
-  
-  return { 
-    vertices, 
-    indices, 
-    vertexCount: posAcc.count, 
-    triangleCount: indices ? indices.length / 3 : 0, 
-    name: mesh.name 
+
+  return {
+    vertices,
+    indices,
+    vertexCount: posAcc.count,
+    triangleCount: indices ? indices.length / 3 : 0,
+    name: mesh.name
+  }
+}
+
+/**
+ * Extract mesh from GLB file with Draco decompression support.
+ * Handles both compressed and uncompressed meshes asynchronously.
+ *
+ * @param {string} filepath - Path to GLB file
+ * @param {number} meshIndex - Mesh index (default 0)
+ * @returns {Promise<Object>} {vertices, indices, vertexCount, triangleCount, name}
+ */
+export async function extractMeshFromGLBAsync(filepath, meshIndex = 0) {
+  console.log(`[GLBLoader] Extracting (async) 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 mesh = json.meshes[meshIndex]
+  if (!mesh) throw new Error(`Mesh index ${meshIndex} not found`)
+
+  const prim = mesh.primitives[0]
+
+  // Handle Draco-compressed mesh
+  if (prim.extensions?.KHR_draco_mesh_compression) {
+    return decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+  }
+
+  // Standard uncompressed extraction
+  const posAcc = json.accessors[prim.attributes.POSITION]
+  const posView = json.bufferViews[posAcc.bufferView]
+  const posOff = binOffset + (posView.byteOffset || 0) + (posAcc.byteOffset || 0)
+  const vertices = new Float32Array(buf.buffer.slice(posOff, posOff + posAcc.count * 12))
+
+  let indices = null
+  if (prim.indices !== undefined) {
+    const idxAcc = json.accessors[prim.indices]
+    const idxView = json.bufferViews[idxAcc.bufferView]
+    const idxOff = binOffset + (idxView.byteOffset || 0) + (idxAcc.byteOffset || 0)
+    if (idxAcc.componentType === 5123) {
+      const raw = new Uint16Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 2))
+      indices = new Uint32Array(raw)
+    } else {
+      indices = new Uint32Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 4))
+    }
+  }
+
+  return {
+    vertices,
+    indices,
+    vertexCount: posAcc.count,
+    triangleCount: indices ? indices.length / 3 : 0,
+    name: mesh.name
+  }
+}
+
+async function decompressDracoMesh(buf, json, prim, binOffset, meshName) {
+  const decoder = await getDracoDecoder()
+
+  const dracoExt = prim.extensions.KHR_draco_mesh_compression
+  const bufViewIdx = dracoExt.bufferView
+  const bufView = json.bufferViews[bufViewIdx]
+  const offset = binOffset + (bufView.byteOffset || 0)
+  const length = bufView.byteLength
+  const dracoData = buf.slice(offset, offset + length)
+
+  // Create decoder and buffer
+  const d = new decoder.Decoder()
+  const db = new decoder.DecoderBuffer()
+
+  try {
+    // Initialize buffer
+    const dracoArray = new Uint8Array(dracoData)
+    db.Init(dracoArray, dracoArray.length)
+
+    // Decode mesh
+    const decodedGeom = d.DecodeBufferToMesh(db)
+    if (!decodedGeom) {
+      throw new Error('Draco decompression failed: empty result')
+    }
+
+    // Get position attribute
+    const posAttrId = d.GetAttributeIdByName(decodedGeom, 'POSITION')
+    if (posAttrId < 0) {
+      throw new Error('No POSITION attribute in decompressed mesh')
+    }
+
+    const posAttr = d.GetAttribute(decodedGeom, posAttrId)
+    const posData = d.GetAttributeFloatForAllPoints(decodedGeom, posAttr)
+    const vertices = new Float32Array(posData)
+
+    // Get indices if available
+    let indices = null
+    if (decodedGeom.num_faces() > 0) {
+      const indicesData = d.GetTrianglesUInt32Array(decodedGeom, decodedGeom.num_faces())
+      indices = new Uint32Array(indicesData)
+    }
+
+    decoder.destroy(decodedGeom)
+
+    return {
+      vertices,
+      indices,
+      vertexCount: decodedGeom.num_points(),
+      triangleCount: decodedGeom.num_faces(),
+      name: meshName
+    }
+  } finally {
+    decoder.destroy(d)
+    decoder.destroy(db)
   }
 }