spoint 0.1.58 → 0.1.60

package/client/app.js

@@ -686,6 +686,7 @@ const entityGroups = new Map()
 const appModules = new Map()
 const entityAppMap = new Map()
 const playerTargets = new Map()
+const entityTargets = new Map()
 let inputHandler = null
 const uiRoot = document.getElementById('ui-root')
 const clickPrompt = document.getElementById('click-prompt')
@@ -1047,8 +1048,13 @@ const client = new PhysicsNetworkClient({
     }
     for (const e of smoothState.entities) {
       const mesh = entityMeshes.get(e.id)
-      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 (mesh && e.position) {
+        const et = entityTargets.get(e.id)
+        if (et) { et.x = e.position[0]; et.y = e.position[1]; et.z = e.position[2]; et.rx = e.rotation?.[0] || 0; et.ry = e.rotation?.[1] || 0; et.rz = e.rotation?.[2] || 0; et.rw = e.rotation?.[3] || 1 }
+        else entityTargets.set(e.id, { x: e.position[0], y: e.position[1], z: e.position[2], rx: e.rotation?.[0] || 0, ry: e.rotation?.[1] || 0, rz: e.rotation?.[2] || 0, rw: e.rotation?.[3] || 1 })
+        const dx = e.position[0] - mesh.position.x, dy = e.position[1] - mesh.position.y, dz = e.position[2] - mesh.position.z
+        if (!mesh.userData.entInit || dx * dx + dy * dy + dz * dz > 100) { mesh.position.set(e.position[0], e.position[1], e.position[2]); if (e.rotation) mesh.quaternion.set(e.rotation[0], e.rotation[1], e.rotation[2], e.rotation[3]); mesh.userData.entInit = true }
+      }
       if (!entityMeshes.has(e.id)) loadEntityModel(e.id, e)
     }
     rebuildEntityHierarchy(smoothState.entities)
@@ -1064,7 +1070,7 @@ const client = new PhysicsNetworkClient({
   onPlayerJoined: (id) => { if (!playerMeshes.has(id)) createPlayerVRM(id) },
   onPlayerLeft: (id) => removePlayerMesh(id),
   onEntityAdded: (id, state) => loadEntityModel(id, state),
-  onEntityRemoved: (id) => { const m = entityMeshes.get(id); if (m) { scene.remove(m); m.traverse(c => { if (c.geometry) c.geometry.dispose(); if (c.material) c.material.dispose() }); entityMeshes.delete(id) }; pendingLoads.delete(id) },
+  onEntityRemoved: (id) => { const m = entityMeshes.get(id); if (m) { scene.remove(m); m.traverse(c => { if (c.geometry) c.geometry.dispose(); if (c.material) c.material.dispose() }); entityMeshes.delete(id) }; entityTargets.delete(id); pendingLoads.delete(id) },
   onWorldDef: (wd) => {
     loadingMgr.setStage('SERVER_SYNC')
     worldConfig = wd
@@ -1212,6 +1218,7 @@ async function initAR() {
         arEnabled = true
         scene.background = null
         ground.visible = false
+        renderer.domElement.style.display = 'none'
         console.log('[AR] AR mode started')
         return true
       }
@@ -1221,6 +1228,7 @@ async function initAR() {
       arEnabled = false
       scene.background = new THREE.Color(0x87ceeb)
       ground.visible = true
+      renderer.domElement.style.display = 'block'
       if (arButton) {
         arButton.textContent = 'Enter XR'
         arButton.style.background = 'rgba(0, 150, 0, 0.8)'
@@ -1494,6 +1502,18 @@ function animate(timestamp) {
       if (features?._headBone) features._headBone.rotation.x = -(ps.lookPitch || 0) * 0.6
     }
   })
+  entityTargets.forEach((target, id) => {
+    const mesh = entityMeshes.get(id)
+    if (!mesh) return
+    mesh.position.x += (target.x - mesh.position.x) * lerpFactor
+    mesh.position.y += (target.y - mesh.position.y) * lerpFactor
+    mesh.position.z += (target.z - mesh.position.z) * lerpFactor
+    mesh.quaternion.x += (target.rx - mesh.quaternion.x) * lerpFactor
+    mesh.quaternion.y += (target.ry - mesh.quaternion.y) * lerpFactor
+    mesh.quaternion.z += (target.rz - mesh.quaternion.z) * lerpFactor
+    mesh.quaternion.w += (target.rw - mesh.quaternion.w) * lerpFactor
+    mesh.quaternion.normalize()
+  })
   entityMeshes.forEach((mesh) => {
     if (mesh.userData.spin) mesh.rotation.y += mesh.userData.spin * frameDt
     if (mesh.userData.hover) {

package/package.json

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

package/src/client/JitterBuffer.js

@@ -1,207 +1,130 @@
 export class JitterBuffer {
   constructor(config = {}) {
-    this.maxSize = config.maxSize || 32
-    this.maxAge = config.maxAge || 200
+    this.maxSize = config.maxSize || 64
     this.minBufferSize = config.minBufferSize || 2
-    this.targetDelay = config.targetDelay || 50
-    
+    this.baseDelay = config.baseDelay || 30
+
     this.buffer = []
-    this.lastProcessTime = 0
     this.lastServerTime = 0
-    this.lastTick = 0
+    this.lastClientTime = 0
     this.rtt = config.initialRtt || 50
     this.rttVariance = 0
-    this.clockDelta = 0
-    this.clockDeltaVariance = 0
-    this.lastClientTime = 0
+    this.jitter = 0
+    this.targetDelay = this.baseDelay
   }
-  
+
   addSnapshot(snapshot) {
     const now = Date.now()
-    const clientTime = now
     const serverTime = snapshot.timestamp || now
-    
-    if (this.lastServerTime > 0) {
+
+    if (this.lastServerTime > 0 && this.lastClientTime > 0) {
       const serverDelta = serverTime - this.lastServerTime
-      const clientDelta = clientTime - this.lastClientTime
-      
+      const clientDelta = now - this.lastClientTime
       if (serverDelta > 0 && clientDelta > 0) {
-        const instantClockDelta = clientDelta - serverDelta
-        this.clockDeltaVariance = this.clockDeltaVariance * 0.9 + Math.abs(instantClockDelta - this.clockDelta) * 0.1
-        this.clockDelta = this.clockDelta * 0.9 + instantClockDelta * 0.1
+        const instantJitter = Math.abs(clientDelta - serverDelta)
+        this.jitter = this.jitter * 0.9 + instantJitter * 0.1
       }
     }
-    
+
     this.lastServerTime = serverTime
-    this.lastClientTime = clientTime
-    
-    this.buffer.push({
-      snapshot,
-      clientTime,
-      serverTime,
-      tick: snapshot.tick || 0
-    })
-    
+    this.lastClientTime = now
+
+    this.buffer.push({ snapshot, clientTime: now, serverTime, tick: snapshot.tick || 0 })
     this.buffer.sort((a, b) => a.tick - b.tick)
-    
-    while (this.buffer.length > this.maxSize) {
-      this.buffer.shift()
-    }
-    
-    this._pruneOld(now)
-  }
-  
-  _pruneOld(now) {
-    const cutoff = now - this.maxAge
-    while (this.buffer.length > 0 && this.buffer[0].clientTime < cutoff) {
-      this.buffer.shift()
-    }
+
+    while (this.buffer.length > this.maxSize) this.buffer.shift()
+
+    const maxAge = Math.max(300, this.rtt + this.jitter * 3)
+    const cutoff = now - maxAge
+    while (this.buffer.length > 0 && this.buffer[0].clientTime < cutoff) this.buffer.shift()
   }
-  
+
   getSnapshotToRender(now = Date.now()) {
+    if (this.buffer.length === 0) return null
     if (this.buffer.length < this.minBufferSize) {
-      if (this.buffer.length === 0) return null
       return this.buffer[this.buffer.length - 1].snapshot
     }
-    
+
     const renderTime = now - this.targetDelay
-    
-    let newest = this.buffer[this.buffer.length - 1]
-    let oldest = this.buffer[0]
-    
-    if (renderTime >= newest.clientTime) {
-      return newest.snapshot
-    }
-    
-    if (renderTime <= oldest.clientTime) {
-      return oldest.snapshot
-    }
-    
+    const newest = this.buffer[this.buffer.length - 1]
+    const oldest = this.buffer[0]
+
+    if (renderTime >= newest.clientTime) return newest.snapshot
+    if (renderTime <= oldest.clientTime) return oldest.snapshot
+
     for (let i = 0; i < this.buffer.length - 1; i++) {
       const curr = this.buffer[i]
       const next = this.buffer[i + 1]
-      
       if (renderTime >= curr.clientTime && renderTime <= next.clientTime) {
         const range = next.clientTime - curr.clientTime
         if (range === 0) return curr.snapshot
-        
         const alpha = (renderTime - curr.clientTime) / range
         return this._interpolateSnapshots(curr.snapshot, next.snapshot, alpha)
       }
     }
-    
+
     return newest.snapshot
   }
-  
+
   _interpolateSnapshots(older, newer, alpha) {
-    const interpolated = {
-      tick: Math.round(older.tick + (newer.tick - older.tick) * alpha),
-      timestamp: older.timestamp + (newer.timestamp - older.timestamp) * alpha,
-      players: [],
-      entities: []
-    }
-    
-    const olderPlayers = new Map()
-    for (const p of older.players || []) {
-      olderPlayers.set(p.id, p)
-    }
-    
+    const result = { tick: newer.tick, timestamp: newer.timestamp, players: [], entities: [] }
+
+    const oldP = new Map()
+    for (const p of older.players || []) oldP.set(p.id, p)
     for (const np of newer.players || []) {
-      const op = olderPlayers.get(np.id)
+      const op = oldP.get(np.id)
       if (op) {
-        interpolated.players.push(this._interpolatePlayer(op, np, alpha))
+        result.players.push({
+          id: np.id,
+          position: [_l(op.position[0], np.position[0], alpha), _l(op.position[1], np.position[1], alpha), _l(op.position[2], np.position[2], alpha)],
+          rotation: np.rotation,
+          velocity: [_l(op.velocity?.[0] || 0, np.velocity?.[0] || 0, alpha), _l(op.velocity?.[1] || 0, np.velocity?.[1] || 0, alpha), _l(op.velocity?.[2] || 0, np.velocity?.[2] || 0, alpha)],
+          onGround: np.onGround, health: np.health, inputSequence: np.inputSequence,
+          crouch: np.crouch,
+          lookPitch: _l(op.lookPitch || 0, np.lookPitch || 0, alpha),
+          lookYaw: _l(op.lookYaw || 0, np.lookYaw || 0, alpha)
+        })
       } else {
-        interpolated.players.push({ ...np })
+        result.players.push({ ...np })
       }
     }
-    
-    const olderEntities = new Map()
-    for (const e of older.entities || []) {
-      olderEntities.set(e.id, e)
-    }
-    
+
+    const oldE = new Map()
+    for (const e of older.entities || []) oldE.set(e.id, e)
     for (const ne of newer.entities || []) {
-      const oe = olderEntities.get(ne.id)
+      const oe = oldE.get(ne.id)
       if (oe) {
-        interpolated.entities.push(this._interpolateEntity(oe, ne, alpha))
+        result.entities.push({
+          id: ne.id, model: ne.model,
+          position: [_l(oe.position[0], ne.position[0], alpha), _l(oe.position[1], ne.position[1], alpha), _l(oe.position[2], ne.position[2], alpha)],
+          rotation: [_l(oe.rotation[0], ne.rotation[0], alpha), _l(oe.rotation[1], ne.rotation[1], alpha), _l(oe.rotation[2], ne.rotation[2], alpha), _l(oe.rotation[3], ne.rotation[3], alpha)],
+          bodyType: ne.bodyType, custom: ne.custom
+        })
       } else {
-        interpolated.entities.push({ ...ne })
+        result.entities.push({ ...ne })
       }
     }
-    
-    return interpolated
-  }
-  
-  _interpolatePlayer(older, newer, alpha) {
-    return {
-      id: newer.id,
-      position: [
-        this._lerp(older.position[0], newer.position[0], alpha),
-        this._lerp(older.position[1], newer.position[1], alpha),
-        this._lerp(older.position[2], newer.position[2], alpha)
-      ],
-      rotation: newer.rotation,
-      velocity: [
-        this._lerp(older.velocity?.[0] || 0, newer.velocity?.[0] || 0, alpha),
-        this._lerp(older.velocity?.[1] || 0, newer.velocity?.[1] || 0, alpha),
-        this._lerp(older.velocity?.[2] || 0, newer.velocity?.[2] || 0, alpha)
-      ],
-      onGround: newer.onGround,
-      health: this._lerp(older.health || 100, newer.health || 100, alpha),
-      inputSequence: newer.inputSequence,
-      crouch: newer.crouch,
-      lookPitch: this._lerp(older.lookPitch || 0, newer.lookPitch || 0, alpha),
-      lookYaw: this._lerp(older.lookYaw || 0, newer.lookYaw || 0, alpha)
-    }
-  }
-  
-  _interpolateEntity(older, newer, alpha) {
-    return {
-      id: newer.id,
-      model: newer.model,
-      position: [
-        this._lerp(older.position[0], newer.position[0], alpha),
-        this._lerp(older.position[1], newer.position[1], alpha),
-        this._lerp(older.position[2], newer.position[2], alpha)
-      ],
-      rotation: [
-        this._lerp(older.rotation[0], newer.rotation[0], alpha),
-        this._lerp(older.rotation[1], newer.rotation[1], alpha),
-        this._lerp(older.rotation[2], newer.rotation[2], alpha),
-        this._lerp(older.rotation[3], newer.rotation[3], alpha)
-      ],
-      bodyType: newer.bodyType,
-      custom: newer.custom
-    }
+
+    return result
   }
-  
-  _lerp(a, b, t) {
-    return a + (b - a) * t
-  }
-  
+
   updateRTT(pingTime, pongTime) {
-    const instantRtt = pongTime - pingTime
-    this.rttVariance = this.rttVariance * 0.75 + Math.abs(instantRtt - this.rtt) * 0.25
-    this.rtt = this.rtt * 0.875 + instantRtt * 0.125
-    
-    this.targetDelay = Math.min(100, Math.max(20, this.rtt / 2 + this.rttVariance))
-  }
-  
-  getBufferHealth() {
-    return this.buffer.length
-  }
-  
-  getRTT() {
-    return this.rtt
-  }
-  
-  getClockDelta() {
-    return this.clockDelta
+    const instant = pongTime - pingTime
+    this.rttVariance = this.rttVariance * 0.75 + Math.abs(instant - this.rtt) * 0.25
+    this.rtt = this.rtt * 0.875 + instant * 0.125
+    this.targetDelay = this.baseDelay + this.rtt * 0.5 + this.jitter * 2
   }
-  
+
+  getBufferHealth() { return this.buffer.length }
+  getRTT() { return this.rtt }
+  getJitter() { return this.jitter }
+  getTargetDelay() { return this.targetDelay }
+
   clear() {
     this.buffer = []
     this.lastServerTime = 0
     this.lastClientTime = 0
   }
-}
+}
+
+function _l(a, b, t) { return a + (b - a) * t }

package/src/client/KalmanFilter.js

@@ -1,89 +1,92 @@
 export class KalmanFilter3D {
   constructor(config = {}) {
-    this.processNoise = config.processNoise || 0.1
-    this.measurementNoise = config.measurementNoise || 0.5
-    this.uncertainty = config.uncertainty || 1.0
-    
+    this.positionQ = config.positionQ ?? 2.0
+    this.velocityQ = config.velocityQ ?? 4.0
+    this.positionR = config.positionR ?? 0.01
+    this.velocityR = config.velocityR ?? 0.1
+
     this.x = [0, 0, 0]
     this.v = [0, 0, 0]
-    
-    this.P = [
-      [this.uncertainty, 0, 0],
-      [0, this.uncertainty, 0],
-      [0, 0, this.uncertainty]
-    ]
-    
+
+    this.Pp = [1, 1, 1]
+    this.Pv = [1, 1, 1]
+
     this.initialized = false
+    this._prevPos = null
+    this._lastUpdateMs = 0
   }
-  
-  init(position, velocity = [0, 0, 0]) {
+
+  init(position, velocity = null, now = Date.now()) {
     this.x = [...position]
-    this.v = [...velocity]
+    this.v = velocity ? [...velocity] : [0, 0, 0]
+    this._prevPos = [...position]
+    this._lastUpdateMs = now
     this.initialized = true
   }
-  
+
   predict(dt) {
-    if (!this.initialized) return { position: this.x, velocity: this.v }
-    
+    if (!this.initialized || dt <= 0) return { position: [...this.x], velocity: [...this.v] }
+
     for (let i = 0; i < 3; i++) {
       this.x[i] += this.v[i] * dt
+      this.Pp[i] += this.positionQ * dt
+      this.Pv[i] += this.velocityQ * dt
     }
-    
-    const q = this.processNoise * dt * dt
-    for (let i = 0; i < 3; i++) {
-      this.P[i][i] += q
-    }
-    
+
     return { position: [...this.x], velocity: [...this.v] }
   }
-  
-  update(measuredPosition, measuredVelocity = null) {
+
+  update(measuredPosition, measuredVelocity = null, now = Date.now()) {
     if (!this.initialized) {
-      this.init(measuredPosition, measuredVelocity || [0, 0, 0])
+      this.init(measuredPosition, measuredVelocity, now)
       return { position: [...this.x], velocity: [...this.v] }
     }
-    
-    const R = this.measurementNoise
-    
+
+    const elapsedMs = now - this._lastUpdateMs
+    if (elapsedMs < 1) return { position: [...this.x], velocity: [...this.v] }
+    const elapsed = elapsedMs / 1000
+    this._lastUpdateMs = now
+
+    for (let i = 0; i < 3; i++) {
+      this.x[i] += this.v[i] * elapsed
+      this.Pp[i] += this.positionQ * elapsed
+      this.Pv[i] += this.velocityQ * elapsed
+    }
+
     for (let i = 0; i < 3; i++) {
-      const P = this.P[i][i]
-      const K = P / (P + R)
-      
-      this.x[i] += K * (measuredPosition[i] - this.x[i])
-      
+      const Kp = this.Pp[i] / (this.Pp[i] + this.positionR)
+      this.x[i] += Kp * (measuredPosition[i] - this.x[i])
+      this.Pp[i] = (1 - Kp) * this.Pp[i]
+
+      let measuredV
       if (measuredVelocity) {
-        this.v[i] = measuredVelocity[i]
+        measuredV = measuredVelocity[i]
+      } else if (this._prevPos) {
+        measuredV = (measuredPosition[i] - this._prevPos[i]) / elapsed
+      } else {
+        measuredV = 0
       }
-      
-      this.P[i][i] = (1 - K) * P
+
+      const Kv = this.Pv[i] / (this.Pv[i] + this.velocityR)
+      this.v[i] += Kv * (measuredV - this.v[i])
+      this.Pv[i] = (1 - Kv) * this.Pv[i]
     }
-    
+
+    this._prevPos = [...measuredPosition]
     return { position: [...this.x], velocity: [...this.v] }
   }
-  
-  getState() {
-    return {
-      position: [...this.x],
-      velocity: [...this.v]
-    }
-  }
-  
-  setPosition(pos) {
-    this.x = [...pos]
-  }
-  
-  setVelocity(vel) {
-    this.v = [...vel]
-  }
-  
+
+  getState() { return { position: [...this.x], velocity: [...this.v] } }
+  setPosition(pos) { this.x = [...pos]; this._prevPos = [...pos] }
+  setVelocity(vel) { this.v = [...vel] }
+
   reset(position = [0, 0, 0]) {
     this.x = [...position]
     this.v = [0, 0, 0]
-    this.P = [
-      [this.uncertainty, 0, 0],
-      [0, this.uncertainty, 0],
-      [0, 0, this.uncertainty]
-    ]
+    this.Pp = [1, 1, 1]
+    this.Pv = [1, 1, 1]
+    this._prevPos = null
+    this._lastUpdateMs = 0
     this.initialized = false
   }
 }
@@ -94,7 +97,7 @@ export class SmoothStateTracker {
     this.maxAge = config.maxAge || 5000
     this.defaultConfig = config.filterConfig || {}
   }
-  
+
   getFilter(id) {
     let filter = this.filters.get(id)
     if (!filter) {
@@ -103,23 +106,17 @@ export class SmoothStateTracker {
     }
     return filter
   }
-  
+
   update(id, position, velocity, dt) {
     const filter = this.getFilter(id)
-    filter.predict(dt)
     return filter.update(position, velocity)
   }
-  
+
   predict(id, dt) {
     const filter = this.getFilter(id)
     return filter.predict(dt)
   }
-  
-  remove(id) {
-    this.filters.delete(id)
-  }
-  
-  clear() {
-    this.filters.clear()
-  }
+
+  remove(id) { this.filters.delete(id) }
+  clear() { this.filters.clear() }
 }

package/src/client/SmoothInterpolation.js

@@ -1,4 +1,4 @@
-import { KalmanFilter3D, SmoothStateTracker } from './KalmanFilter.js'
+import { KalmanFilter3D } from './KalmanFilter.js'
 import { JitterBuffer } from './JitterBuffer.js'
 
 export class SmoothInterpolation {
@@ -6,122 +6,96 @@ export class SmoothInterpolation {
     this.jitterBuffer = new JitterBuffer(config.jitter || {})
     this.playerFilters = new Map()
     this.entityFilters = new Map()
-    this.kalmanConfig = config.kalman || {
-      processNoise: 0.08,
-      measurementNoise: 0.3,
-      uncertainty: 0.5
+    this.playerKalmanConfig = config.playerKalman || {
+      positionQ: 2.0, velocityQ: 4.0, positionR: 0.01, velocityR: 0.1
     }
-    
-    this.lastFrameTime = Date.now()
+    this.entityKalmanConfig = config.entityKalman || {
+      positionQ: 2.0, velocityQ: 4.0, positionR: 0.01, velocityR: 0.5
+    }
+
     this.localPlayerId = null
     this.predictionEnabled = config.predictionEnabled !== false
-    this.extrapolationLimit = config.extrapolationLimit || 100
-  }
-  
-  setLocalPlayer(id) {
-    this.localPlayerId = id
+    this._lastDisplayTime = 0
   }
-  
+
+  setLocalPlayer(id) { this.localPlayerId = id }
+
   addSnapshot(snapshot) {
     this.jitterBuffer.addSnapshot(snapshot)
+    const now = Date.now()
+    for (const p of snapshot.players || []) {
+      if (p.id === this.localPlayerId && this.predictionEnabled) continue
+      let filter = this.playerFilters.get(p.id)
+      if (!filter) {
+        filter = new KalmanFilter3D(this.playerKalmanConfig)
+        this.playerFilters.set(p.id, filter)
+      }
+      filter.update(p.position, p.velocity, now)
+    }
+    for (const e of snapshot.entities || []) {
+      let filter = this.entityFilters.get(e.id)
+      if (!filter) {
+        filter = new KalmanFilter3D(this.entityKalmanConfig)
+        this.entityFilters.set(e.id, filter)
+      }
+      filter.update(e.position, null, now)
+    }
   }
-  
+
   getDisplayState(now = Date.now()) {
     const snapshot = this.jitterBuffer.getSnapshotToRender(now)
     if (!snapshot) return { players: [], entities: [] }
-    
-    const dt = Math.min((now - this.lastFrameTime) / 1000, 0.1)
-    this.lastFrameTime = now
-    
+
+    const dt = this._lastDisplayTime > 0 ? Math.min((now - this._lastDisplayTime) / 1000, 0.1) : 0
+    this._lastDisplayTime = now
+
     const displayPlayers = []
     for (const player of snapshot.players || []) {
       if (player.id === this.localPlayerId && this.predictionEnabled) {
         displayPlayers.push(player)
         continue
       }
-      
-      const smoothed = this._smoothPlayer(player, dt)
-      displayPlayers.push(smoothed)
+      const filter = this.playerFilters.get(player.id)
+      if (filter && dt > 0) {
+        const predicted = filter.predict(dt)
+        displayPlayers.push({ ...player, position: predicted.position, velocity: predicted.velocity })
+      } else {
+        displayPlayers.push(player)
+      }
     }
-    
+
     const displayEntities = []
     for (const entity of snapshot.entities || []) {
-      const smoothed = this._smoothEntity(entity, dt)
-      displayEntities.push(smoothed)
+      const filter = this.entityFilters.get(entity.id)
+      if (filter && dt > 0) {
+        const predicted = filter.predict(dt)
+        displayEntities.push({ ...entity, position: predicted.position })
+      } else {
+        displayEntities.push(entity)
+      }
     }
-    
+
     return { players: displayPlayers, entities: displayEntities }
   }
-  
-  _smoothPlayer(player, dt) {
-    let filter = this.playerFilters.get(player.id)
-    if (!filter) {
-      filter = new KalmanFilter3D(this.kalmanConfig)
-      this.playerFilters.set(player.id, filter)
-    }
-    
-    const state = filter.update(player.position, player.velocity)
-    
-    return {
-      ...player,
-      position: state.position,
-      velocity: state.velocity
-    }
-  }
-  
-  _smoothEntity(entity, dt) {
-    let filter = this.entityFilters.get(entity.id)
-    if (!filter) {
-      filter = new KalmanFilter3D(this.kalmanConfig)
-      this.entityFilters.set(entity.id, filter)
-    }
-    
-    const state = filter.update(entity.position)
-    
-    return {
-      ...entity,
-      position: state.position
-    }
-  }
-  
-  predictStep(dt) {
-    for (const [id, filter] of this.playerFilters) {
-      filter.predict(dt)
-    }
-    for (const [id, filter] of this.entityFilters) {
-      filter.predict(dt)
-    }
-  }
-  
-  removePlayer(id) {
-    this.playerFilters.delete(id)
-  }
-  
-  removeEntity(id) {
-    this.entityFilters.delete(id)
-  }
-  
-  updateRTT(pingTime, pongTime) {
-    this.jitterBuffer.updateRTT(pingTime, pongTime)
-  }
-  
-  getRTT() {
-    return this.jitterBuffer.getRTT()
-  }
-  
-  getBufferHealth() {
-    return this.jitterBuffer.getBufferHealth()
-  }
-  
+
+  removePlayer(id) { this.playerFilters.delete(id) }
+  removeEntity(id) { this.entityFilters.delete(id) }
+
+  updateRTT(pingTime, pongTime) { this.jitterBuffer.updateRTT(pingTime, pongTime) }
+  getRTT() { return this.jitterBuffer.getRTT() }
+  getJitter() { return this.jitterBuffer.getJitter() }
+  getTargetDelay() { return this.jitterBuffer.getTargetDelay() }
+  getBufferHealth() { return this.jitterBuffer.getBufferHealth() }
+
   reset() {
     this.jitterBuffer.clear()
     this.playerFilters.clear()
     this.entityFilters.clear()
+    this._lastDisplayTime = 0
   }
-  
+
   setConfig(config) {
-    if (config.kalman) {
-      this.kalmanConfig = { ...this.kalmanConfig, ...config.kalman }
-    }
+    if (config.playerKalman) this.playerKalmanConfig = { ...this.playerKalmanConfig, ...config.playerKalman }
+    if (config.entityKalman) this.entityKalmanConfig = { ...this.entityKalmanConfig, ...config.entityKalman }
   }
-}
+}