spoint 0.1.76 → 0.1.78

package/apps/environment/index.js

@@ -25,10 +25,12 @@ export default {
   server: {
     setup(ctx) {
       ctx.physics.setStatic(true)
+      // Use trimesh collider for environment - handles both compressed and uncompressed
       try {
         ctx.physics.addTrimeshCollider()
       } catch (e) {
-        ctx.debug.log(`[Environment] Trimesh collider failed (likely Draco compression), using fallback box collider: ${e.message}`)
+        // Fallback if trimesh extraction fails (e.g., unsupported model format)
+        console.log(`[Environment] Trimesh collider failed: ${e.message}`)
         ctx.physics.addBoxCollider([50, 0.5, 50])
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "main": "src/index.js",
@@ -41,8 +41,12 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "@gltf-transform/extensions": "^4.3.0",
     "d3-octree": "^1.1.0",
+    "draco3d": "^1.5.7",
+    "draco3dgltf": "^1.5.7",
     "jolt-physics": "^0.29.0",
+    "meshoptimizer": "^1.0.1",
     "webjsx": "^0.0.73",
     "ws": "^8.18.0"
   },
@@ -51,6 +55,9 @@
     "@fails-components/webtransport-transport-http3-quiche": "^1.5.3"
   },
   "devDependencies": {
-    "playwright": "^1.58.1"
+    "@gltf-transform/cli": "^4.3.0",
+    "@gltf-transform/core": "^4.3.0",
+    "playwright": "^1.58.1",
+    "three": "^0.183.1"
   }
 }

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,66 +1,184 @@
 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(buf.byteOffset + posOff, buf.byteOffset + posOff + posAcc.count * 12))
-  
+  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
+  }
+}
+
+/**
+ * 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(buf.byteOffset + idxOff, buf.byteOffset + idxOff + idxAcc.count * 2))
+      const raw = new Uint16Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 2))
       indices = new Uint32Array(raw)
     } else {
-      indices = new Uint32Array(buf.buffer.slice(buf.byteOffset + idxOff, buf.byteOffset + idxOff + idxAcc.count * 4))
+      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
+  }
+}
+
+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)
   }
 }