ChunkManager

Author: michaljaz

src/scripts/world/ChunkManager.js

@@ -0,0 +1,59 @@
+import { BufferGeometry, BufferAttribute, Mesh } from 'three'
+
+class ChunkManager {
+  constructor (game) {
+    this.game = game
+    this.chunks = new Map()
+    this.cellMesh = new Map()
+  }
+
+  addChunk (cellId, vert) {
+    this.chunks.set(cellId, vert)
+
+    const geometry = new BufferGeometry()
+    geometry.setAttribute('position', new BufferAttribute(new Float32Array(vert.positions), 3))
+    geometry.setAttribute('normal', new BufferAttribute(new Float32Array(vert.normals), 3))
+    geometry.setAttribute('uv', new BufferAttribute(new Float32Array(vert.uvs), 2))
+    geometry.setAttribute('color', new BufferAttribute(new Float32Array(vert.colors), 3))
+    geometry.matrixAutoUpdate = false
+
+    const mesh = this.cellMesh.get(cellId)
+    if (mesh === undefined) {
+      const newMesh = new Mesh(geometry, this.game.world.material)
+      newMesh.matrixAutoUpdate = false
+      newMesh.frustumCulled = false
+      newMesh.onAfterRender = () => {
+        newMesh.frustumCulled = true
+        newMesh.onAfterRender = function () {}
+      }
+      this.cellMesh.set(cellId, newMesh)
+      this.game.scene.add(newMesh)
+      if (this.game.world.lastPlayerChunk !== null) {
+        this.game.world.updateRenderOrder(JSON.parse(this.game.world.lastPlayerChunk))
+      }
+    } else {
+      this.cellMesh.get(cellId).geometry = geometry
+    }
+  }
+
+  removeChunk (cellId) {
+    if (this.chunks.get(cellId) !== undefined) {
+      this.cellMesh.get(cellId).geometry.dispose()
+      this.game.scene.remove(this.cellMesh.get(cellId))
+      this.cellMesh.delete(cellId)
+      this.game.renderer.renderLists.dispose()
+    }
+  }
+
+  reset () {
+    for (const i of this.cellMesh) {
+      if (i[1].geometry !== undefined) {
+        i[1].geometry.dispose()
+        this.game.scene.remove(i[1])
+      }
+    }
+    this.cellMesh.clear()
+    this.chunks.clear()
+  }
+}
+export { ChunkManager }

src/scripts/world/ChunkMerger.js

@@ -113,6 +113,92 @@ class ChunkTerrain {
     return [main, neighbours]
   }
 
+  intersectsRay (start, end) {
+    start.x += 0.5
+    start.y += 0.5
+    start.z += 0.5
+    end.x += 0.5
+    end.y += 0.5
+    end.z += 0.5
+    let dx = end.x - start.x
+    let dy = end.y - start.y
+    let dz = end.z - start.z
+    const lenSq = dx * dx + dy * dy + dz * dz
+    const len = Math.sqrt(lenSq)
+    dx /= len
+    dy /= len
+    dz /= len
+    let t = 0.0
+    let ix = Math.floor(start.x)
+    let iy = Math.floor(start.y)
+    let iz = Math.floor(start.z)
+    const stepX = dx > 0 ? 1 : -1
+    const stepY = dy > 0 ? 1 : -1
+    const stepZ = dz > 0 ? 1 : -1
+    const txDelta = Math.abs(1 / dx)
+    const tyDelta = Math.abs(1 / dy)
+    const tzDelta = Math.abs(1 / dz)
+    const xDist = stepX > 0 ? ix + 1 - start.x : start.x - ix
+    const yDist = stepY > 0 ? iy + 1 - start.y : start.y - iy
+    const zDist = stepZ > 0 ? iz + 1 - start.z : start.z - iz
+    let txMax = txDelta < Infinity ? txDelta * xDist : Infinity
+    let tyMax = tyDelta < Infinity ? tyDelta * yDist : Infinity
+    let tzMax = tzDelta < Infinity ? tzDelta * zDist : Infinity
+    let steppedIndex = -1
+    while (t <= len) {
+      const block = this.getBlock(ix, iy, iz)
+      let voxel
+      if (
+        block.name === 'air' || block.name === 'cave_air' || block.name === 'void_air' || block.name === 'water'
+      ) {
+        voxel = 0
+      } else {
+        voxel = 1
+      }
+      if (voxel) {
+        return {
+          position: [
+            start.x + t * dx,
+            start.y + t * dy,
+            start.z + t * dz
+          ],
+          normal: [
+            steppedIndex === 0 ? -stepX : 0,
+            steppedIndex === 1 ? -stepY : 0,
+            steppedIndex === 2 ? -stepZ : 0
+          ],
+          voxel
+        }
+      }
+      if (txMax < tyMax) {
+        if (txMax < tzMax) {
+          ix += stepX
+          t = txMax
+          txMax += txDelta
+          steppedIndex = 0
+        } else {
+          iz += stepZ
+          t = tzMax
+          tzMax += tzDelta
+          steppedIndex = 2
+        }
+      } else {
+        if (tyMax < tzMax) {
+          iy += stepY
+          t = tyMax
+          tyMax += tyDelta
+          steppedIndex = 1
+        } else {
+          iz += stepZ
+          t = tzMax
+          tzMax += tzDelta
+          steppedIndex = 2
+        }
+      }
+    }
+    return null
+  }
+
   reset () {
     this.chunks = {}
   }