spoint 0.1.28 → 0.1.30

package/client/animation.js

@@ -46,15 +46,15 @@ function filterUpperBodyTracks(clip) {
   return new THREE.AnimationClip(clip.name, clip.duration, filteredTracks)
 }
 
-function filterValidClipTracks(clip, targetObj) {
-  // Get all bone/mesh names that exist in target
+function buildValidBoneSet(targetObj) {
   const validBones = new Set()
   targetObj.traverse(child => {
-    if (child.isBone || child.isSkinnedMesh) {
-      validBones.add(child.name)
-    }
+    if (child.isBone || child.isSkinnedMesh) validBones.add(child.name)
   })
+  return validBones
+}
 
+function filterValidClipTracks(clip, validBones) {
   const validTracks = clip.tracks.filter(track => {
     const boneName = extractBoneName(track.name)
     if (!validBones.has(boneName)) {
@@ -140,6 +140,7 @@ export function createPlayerAnimator(vrm, allClips, vrmVersion, animConfig = {})
   const additiveActions = new Map()
 
   const clips = allClips.normalizedClips || allClips.rawClips || allClips
+  const validBones = buildValidBoneSet(root)
 
   for (const [name, clip] of clips) {
     if (!STATES[name]) continue
@@ -149,7 +150,7 @@ export function createPlayerAnimator(vrm, allClips, vrmVersion, animConfig = {})
       console.log(`[anim] ${name} tracks:`, clip.tracks.map(t => extractBoneName(t.name)))
     }
 
-    let playClip = filterValidClipTracks(clip, root)
+    let playClip = filterValidClipTracks(clip, validBones)
 
     if (cfg.upperBody) {
       const upperBodyClip = filterUpperBodyTracks(playClip)

package/client/app.js

@@ -659,6 +659,7 @@ scene.add(ground)
 
 const loadingManager = new THREE.LoadingManager()
 loadingManager.onError = (url) => console.warn('[THREE] Failed to load:', url)
+THREE.Cache.enabled = true
 const gltfLoader = new GLTFLoader(loadingManager)
 const dracoLoader = new DRACOLoader(loadingManager)
 dracoLoader.setDecoderPath('/draco/')
@@ -771,13 +772,15 @@ function initVRMFeatures(id, vrm) {
   playerExpressions.set(id, features)
 }
 
+const _lookTargetVec = new THREE.Vector3()
+
 function updateVRMFeatures(id, dt, targetPosition) {
   const features = playerExpressions.get(id)
   if (!features) return
   if (features.springBone) features.springBone.update(dt)
   if (features.lookAt && targetPosition) {
-    const lookTarget = new THREE.Vector3(targetPosition.x, targetPosition.y + 1.6, targetPosition.z)
-    features.lookAt.lookAt(lookTarget)
+    _lookTargetVec.set(targetPosition.x, targetPosition.y + 1.6, targetPosition.z)
+    features.lookAt.lookAt(_lookTargetVec)
   }
   if (features.expressions) {
     features.blinkTimer += dt
@@ -891,18 +894,13 @@ function rebuildEntityHierarchy(entities) {
     if (!mesh) continue
 
     const parentId = entityParentMap.get(e.id)
-    const currentParent = mesh.parent && mesh.parent !== scene ? mesh.parent : null
-    const currentParentId = Array.from(entityParentMap.entries()).find(([k, v]) => v === null || entityMeshes.get(k) === currentParent)?.[0]
+    const currentParent = mesh.parent !== scene ? mesh.parent : null
 
     if (parentId === null) {
-      if (currentParent && currentParent !== scene) {
-        scene.add(mesh)
-      }
+      if (currentParent) scene.add(mesh)
     } else {
       const parentMesh = entityMeshes.get(parentId)
-      if (parentMesh && parentMesh !== currentParent) {
-        parentMesh.add(mesh)
-      }
+      if (parentMesh && parentMesh !== currentParent) parentMesh.add(mesh)
     }
   }
 }
@@ -921,8 +919,8 @@ function loadEntityModel(entityId, entityState) {
     } else {
       group = buildEntityMesh(entityId, entityState.custom)
     }
-    group.position.set(...entityState.position)
-    if (entityState.rotation) group.quaternion.set(...entityState.rotation)
+    const ep = entityState.position; group.position.set(ep[0], ep[1], ep[2])
+    const er = entityState.rotation; if (er) group.quaternion.set(er[0], er[1], er[2], er[3])
     scene.add(group)
     entityMeshes.set(entityId, group)
     pendingLoads.delete(entityId)
@@ -933,13 +931,20 @@ function loadEntityModel(entityId, entityState) {
   const url = entityState.model.startsWith('./') ? '/' + entityState.model.slice(2) : entityState.model
   gltfLoader.load(url, (gltf) => {
     const model = gltf.scene
-    model.position.set(...entityState.position)
-    if (entityState.rotation) model.quaternion.set(...entityState.rotation)
-    model.traverse(c => { if (c.isMesh) { c.castShadow = true; c.receiveShadow = true; if (c.material) { c.material.shadowSide = THREE.DoubleSide; c.material.roughness = 1; c.material.metalness = 0; if (c.material.specularIntensity !== undefined) c.material.specularIntensity = 0 } } })
+    const mp = entityState.position; model.position.set(mp[0], mp[1], mp[2])
+    const mr = entityState.rotation; if (mr) model.quaternion.set(mr[0], mr[1], mr[2], mr[3])
+    const colliders = []
+    model.traverse(c => {
+      if (c.isMesh) {
+        c.castShadow = true
+        c.receiveShadow = true
+        if (!c.isSkinnedMesh) { c.matrixAutoUpdate = false; colliders.push(c) }
+        if (c.material) { c.material.shadowSide = THREE.DoubleSide; c.material.roughness = 1; c.material.metalness = 0; if (c.material.specularIntensity !== undefined) c.material.specularIntensity = 0 }
+      }
+    })
+    model.updateMatrixWorld(true)
     scene.add(model)
     entityMeshes.set(entityId, model)
-    const colliders = []
-    model.traverse(c => { if (c.isMesh && !c.isSkinnedMesh) colliders.push(c) })
     cam.setEnvironment(colliders)
     scene.remove(ground)
     fitShadowFrustum()
@@ -978,15 +983,17 @@ const client = new PhysicsNetworkClient({
       const mesh = playerMeshes.get(p.id)
       const feetOff = mesh?.userData?.feetOffset ?? 1.3
       const tx = p.position[0], ty = p.position[1] - feetOff, tz = p.position[2]
-      playerTargets.set(p.id, { x: tx, y: ty, z: tz })
+      const existingTarget = playerTargets.get(p.id)
+      if (existingTarget) { existingTarget.x = tx; existingTarget.y = ty; existingTarget.z = tz }
+      else playerTargets.set(p.id, { x: tx, y: ty, z: tz })
       playerStates.set(p.id, p)
       const dx = tx - mesh.position.x, dy = ty - mesh.position.y, dz = tz - mesh.position.z
       if (!mesh.userData.initialized || dx * dx + dy * dy + dz * dz > 100) { mesh.position.set(tx, ty, tz); mesh.userData.initialized = true }
     }
     for (const e of smoothState.entities) {
       const mesh = entityMeshes.get(e.id)
-      if (mesh && e.position) mesh.position.set(...e.position)
-      if (mesh && e.rotation) mesh.quaternion.set(...e.rotation)
+      if (mesh && e.position) mesh.position.set(e.position[0], e.position[1], e.position[2])
+      if (mesh && e.rotation) mesh.quaternion.set(e.rotation[0], e.rotation[1], e.rotation[2], e.rotation[3])
       if (!entityMeshes.has(e.id)) loadEntityModel(e.id, e)
     }
     rebuildEntityHierarchy(smoothState.entities)
@@ -1015,12 +1022,13 @@ const client = new PhysicsNetworkClient({
     const a = evaluateAppModule(d.code)
     if (a?.client) {
       appModules.set(d.app, a.client)
+      _appModuleList = [...appModules.values()]
       if (a.client.setup) try { a.client.setup(engineCtx) } catch (e) { console.error('[app-setup]', d.app, e.message) }
     }
   },
   onAssetUpdate: () => {},
   onAppEvent: (payload) => {
-    for (const [, mod] of appModules) { if (mod.onEvent) try { mod.onEvent(payload, engineCtx) } catch (e) { console.error('[app-event]', e.message) } }
+    for (let _i = 0; _i < _appModuleList.length; _i++) { const mod = _appModuleList[_i]; if (mod.onEvent) try { mod.onEvent(payload, engineCtx) } catch (e) { console.error('[app-event]', e.message) } }
   },
   onHotReload: () => { sessionStorage.setItem('cam', JSON.stringify(cam.save())); location.reload() },
   debug: false
@@ -1091,7 +1099,7 @@ function initInputHandler() {
     setTimeout(() => {
       xrBaseReferenceSpace = renderer.xr.getReferenceSpace()
       if (!xrBaseReferenceSpace) return
-      const local = client.state?.players?.find(p => p.id === client.playerId)
+      const local = playerStates.get(client.playerId)
       if (local?.position) {
         const headHeight = local.crouch ? 1.1 : 1.6
         const pos = { x: -local.position[0], y: -(local.position[1] + headHeight), z: -local.position[2] }
@@ -1220,7 +1228,7 @@ function startInputLoop() {
       inputHandler.pulse('right', 0.5, 100)
     }
     lastShootState = input.shoot
-    const local = client.state?.players?.find(p => p.id === client.playerId)
+    const local = playerStates.get(client.playerId)
     if (local) {
       if (local.health < lastHealth) {
         inputHandler.pulse('left', 0.8, 200)
@@ -1228,7 +1236,7 @@ function startInputLoop() {
       }
       lastHealth = local.health
     }
-    for (const [, mod] of appModules) { if (mod.onInput) try { mod.onInput(input, engineCtx) } catch (e) { console.error('[app-input]', e.message) } }
+    for (let _i = 0; _i < _appModuleList.length; _i++) { const mod = _appModuleList[_i]; if (mod.onInput) try { mod.onInput(input, engineCtx) } catch (e) { console.error('[app-input]', e.message) } }
     client.sendInput(input)
   }, 1000 / 60)
 }
@@ -1241,8 +1249,8 @@ document.addEventListener('pointerlockchange', () => {
   else document.removeEventListener('mousemove', cam.onMouseMove)
 })
 renderer.domElement.addEventListener('wheel', cam.onWheel, { passive: false })
-renderer.domElement.addEventListener('mousedown', (e) => { for (const [, mod] of appModules) { if (mod.onMouseDown) try { mod.onMouseDown(e, engineCtx) } catch (ex) {} } })
-renderer.domElement.addEventListener('mouseup', (e) => { for (const [, mod] of appModules) { if (mod.onMouseUp) try { mod.onMouseUp(e, engineCtx) } catch (ex) {} } })
+renderer.domElement.addEventListener('mousedown', (e) => { for (let _i = 0; _i < _appModuleList.length; _i++) { const mod = _appModuleList[_i]; if (mod.onMouseDown) try { mod.onMouseDown(e, engineCtx) } catch (ex) {} } })
+renderer.domElement.addEventListener('mouseup', (e) => { for (let _i = 0; _i < _appModuleList.length; _i++) { const mod = _appModuleList[_i]; if (mod.onMouseUp) try { mod.onMouseUp(e, engineCtx) } catch (ex) {} } })
 renderer.domElement.addEventListener('contextmenu', (e) => e.preventDefault())
 window.addEventListener('resize', () => { camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight) })
 
@@ -1283,7 +1291,7 @@ function loadQueuedModels() {
     try {
       const buffer = e.target.result
       gltfLoader.parse(buffer, '', (gltf) => {
-        const local = client.state?.players?.find(p => p.id === client.playerId)
+        const local = playerStates.get(client.playerId)
         if (!local) return
         const sy = Math.sin(cam.yaw), cy = Math.cos(cam.yaw)
         const spawnDist = 1.0
@@ -1354,6 +1362,7 @@ document.addEventListener('drop', (e) => {
 })
 
 let smoothDt = 1 / 60
+let _appModuleList = []
 function animate(timestamp) {
   const now = timestamp || performance.now()
   const rawDt = Math.min((now - lastFrameTime) / 1000, 0.1)
@@ -1363,53 +1372,53 @@ function animate(timestamp) {
   fpsFrames++
   if (now - fpsLast >= 1000) { fpsDisplay = fpsFrames; fpsFrames = 0; fpsLast = now }
   const lerpFactor = 1.0 - Math.exp(-16.0 * frameDt)
-  for (const [id, target] of playerTargets) {
+  playerTargets.forEach((target, id) => {
     const mesh = playerMeshes.get(id)
-    if (!mesh) continue
+    if (!mesh) return
     const ps = playerStates.get(id)
     const vx = ps?.velocity?.[0] || 0, vy = ps?.velocity?.[1] || 0, vz = ps?.velocity?.[2] || 0
     const goalX = target.x + vx * frameDt, goalY = target.y + vy * frameDt, goalZ = target.z + vz * frameDt
     mesh.position.x += (goalX - mesh.position.x) * lerpFactor
     mesh.position.y += (goalY - mesh.position.y) * lerpFactor
     mesh.position.z += (goalZ - mesh.position.z) * lerpFactor
-  }
-  for (const [id, animator] of playerAnimators) {
+  })
+  playerAnimators.forEach((animator, id) => {
     const ps = playerStates.get(id)
-    if (!ps) continue
+    if (!ps) return
     animator.update(frameDt, ps.velocity, ps.onGround, ps.health, ps._aiming || false, ps.crouch || 0)
     const mesh = playerMeshes.get(id)
-    if (!mesh) continue
+    if (!mesh) return
     const vx = ps.velocity?.[0] || 0, vz = ps.velocity?.[2] || 0
-    if (Math.sqrt(vx * vx + vz * vz) > 0.5) mesh.userData.lastYaw = Math.atan2(vx, vz)
+    if (vx * vx + vz * vz > 0.25) mesh.userData.lastYaw = Math.atan2(vx, vz)
     if (mesh.userData.lastYaw !== undefined) {
       let diff = mesh.userData.lastYaw - mesh.rotation.y
-      while (diff > Math.PI) diff -= Math.PI * 2
-      while (diff < -Math.PI) diff += Math.PI * 2
+      diff = diff - Math.PI * 2 * Math.round(diff / (Math.PI * 2))
       mesh.rotation.y += diff * lerpFactor
     }
     const target = playerTargets.get(id)
     updateVRMFeatures(id, frameDt, target)
     if (id !== client.playerId && ps.lookPitch !== undefined) {
-      const vrm = playerVrms.get(id)
-      if (vrm?.humanoid) {
-        const head = vrm.humanoid.getNormalizedBoneNode('head')
-        if (head) head.rotation.x = -(ps.lookPitch || 0) * 0.6
+      const features = playerExpressions.get(id)
+      if (features && !features._headBone) {
+        const vrm = playerVrms.get(id)
+        if (vrm?.humanoid) features._headBone = vrm.humanoid.getNormalizedBoneNode('head')
       }
+      if (features?._headBone) features._headBone.rotation.x = -(ps.lookPitch || 0) * 0.6
     }
-  }
-  for (const [eid, mesh] of entityMeshes) {
+  })
+  entityMeshes.forEach((mesh) => {
     if (mesh.userData.spin) mesh.rotation.y += mesh.userData.spin * frameDt
     if (mesh.userData.hover) {
       mesh.userData.hoverTime = (mesh.userData.hoverTime || 0) + frameDt
       const child = mesh.children[0]
       if (child) child.position.y = Math.sin(mesh.userData.hoverTime * 2) * mesh.userData.hover
     }
-  }
-  for (const [, mod] of appModules) { if (mod.onFrame) try { mod.onFrame(frameDt, engineCtx) } catch (e) {} }
+  })
+  for (let _i = 0; _i < _appModuleList.length; _i++) { const mod = _appModuleList[_i]; if (mod.onFrame) try { mod.onFrame(frameDt, engineCtx) } catch (e) {} }
   if (engineCtx.facial) engineCtx.facial.update(frameDt)
   uiTimer += frameDt
   if (latestState && uiTimer >= 0.25) { uiTimer = 0; renderAppUI(latestState) }
-  const local = client.state?.players?.find(p => p.id === client.playerId)
+  const local = playerStates.get(client.playerId)
   const inVR = renderer.xr.isPresenting
   if (!inVR || cam.getEditMode()) {
     cam.update(local, playerMeshes.get(client.playerId), frameDt, latestInput)
@@ -1435,15 +1444,15 @@ function animate(timestamp) {
     const speed = Math.sqrt(local.velocity[0] ** 2 + local.velocity[2] ** 2)
     isMoving = speed > 0.5
   }
-updateVignette(frameDt, isMoving)
+  updateVignette(frameDt, isMoving)
 
   if (arEnabled) {
     const xrFrame = renderer.xr.getFrame()
     if (xrFrame) {
       arControls.update(xrFrame, camera, scene)
-      const local = client.state?.players?.find(p => p.id === client.playerId)
-      if (local?.position && !arControls.anchorPlaced) {
-        arControls.setInitialFPSPosition(local.position, cam.yaw)
+      const arLocal = playerStates.get(client.playerId)
+      if (arLocal?.position && !arControls.anchorPlaced) {
+        arControls.setInitialFPSPosition(arLocal.position, cam.yaw)
       }
     }
   }

package/package.json

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