Group multi-block updates when updating meshes to avoid duplicate updates

Author: stackotter

.swiftlint.yml

@@ -19,7 +19,7 @@ line_length: 160
 type_body_length: 300
 function_parameter_count: 8
 file_length: 500
-function_body_length: 50 
+function_body_length: 50
 cyclomatic_complexity:
   error: 40 # TODO: reset once more occurrences are fixed
 

Sources/Core/Renderer/World/WorldRenderer.swift

@@ -285,13 +285,23 @@ public final class WorldRenderer: Renderer {
           worldMesh.updateSection(at: position)
         }
 
-      case let event as World.Event.SetBlock:
+      case let event as World.Event.SingleBlockUpdate:
         let affectedSections = worldMesh.sectionsAffectedBySectionUpdate(at: event.position.chunkSection)
 
         for position in affectedSections {
           worldMesh.updateSection(at: position)
         }
 
+      case let event as World.Event.MultiBlockUpdate:
+        var affectedSections: Set<ChunkSectionPosition> = []
+        for update in event.updates {
+          affectedSections.formUnion(worldMesh.sectionsAffectedBySectionUpdate(at: update.position.chunkSection))
+        }
+
+        for position in affectedSections {
+          worldMesh.updateSection(at: position)
+        }
+
       case let event as World.Event.UpdateChunk:
         var affectedSections: Set<ChunkSectionPosition> = []
 

Sources/Core/Sources/Network/Protocol/PacketRegistry.swift

@@ -51,7 +51,7 @@ public struct PacketRegistry {
       BossBarPacket.self,
       ServerDifficultyPacket.self,
       ChatMessageClientboundPacket.self,
-      MultiBlockChangePacket.self,
+      MultiBlockUpdatePacket.self,
       TabCompleteClientboundPacket.self,
       DeclareCommandsPacket.self,
       WindowConfirmationClientboundPacket.self,

Sources/Core/Sources/Network/Protocol/Packets/Play/Clientbound/MultiBlockChangePacket.swift renamed to Sources/Core/Sources/Network/Protocol/Packets/Play/Clientbound/MultiBlockUpdatePacket.swift

@@ -1,10 +1,10 @@
 import Foundation
 
-public struct MultiBlockChangePacket: ClientboundPacket {
+public struct MultiBlockUpdatePacket: ClientboundPacket {
   public static let id: Int = 0x0f
 
   /// A block change in a multi-block change.
-  public struct BlockChangeRecord {
+  public struct BlockUpdateRecord {
     /// X coordinate of the block change relative to the chunk.
     public var x: UInt8
     /// Y coordinate of the block change relative to the chunk.
@@ -19,7 +19,7 @@ public struct MultiBlockChangePacket: ClientboundPacket {
   /// The position of the chunk the multi-block change occured in.
   public var chunkPosition: ChunkPosition
   /// The block changes.
-  public var records: [BlockChangeRecord]
+  public var records: [BlockUpdateRecord]
 
   public init(from packetReader: inout PacketReader) throws {
     let chunkX = try packetReader.readInt()
@@ -35,24 +35,23 @@ public struct MultiBlockChangePacket: ClientboundPacket {
       let z = value & 0x0f
       let y = try packetReader.readUnsignedByte()
       let blockId = try packetReader.readVarInt()
-      let record = BlockChangeRecord(x: x, y: y, z: z, blockId: blockId)
+      let record = BlockUpdateRecord(x: x, y: y, z: z, blockId: blockId)
       records.append(record)
     }
   }
 
   public func handle(for client: Client) throws {
-    print("Multi block change")
     let updates = records.map { record in
-      return (
+      return World.Event.SingleBlockUpdate(
         position: BlockPosition(
           x: Int(record.x) + chunkPosition.chunkX * Chunk.width,
           y: Int(record.y),
           z: Int(record.z) + chunkPosition.chunkZ * Chunk.depth
         ),
-        state: record.blockId
+        newState: record.blockId
       )
     }
 
-    client.game.world.processMultiBlockChange(at: chunkPosition, updates)
+    client.game.world.processMultiBlockUpdate(updates, inChunkAt: chunkPosition)
   }
 }

Sources/Core/Sources/Plugin/Event/World/MultiBlockUpdate.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+extension World.Event {
+  /// An event triggered when multiple blocks are updated at once.
+  public struct MultiBlockUpdate: Event {
+    public let updates: [SingleBlockUpdate]
+
+    public init(updates: [SingleBlockUpdate]) {
+      self.updates = updates
+    }
+  }
+}

Sources/Core/Sources/Plugin/Event/World/SetBlock.swift renamed to Sources/Core/Sources/Plugin/Event/World/SingleBlockUpdate.swift

@@ -1,10 +1,12 @@
 import Foundation
 
 extension World.Event {
-  public struct SetBlock: Event {
+  /// An event triggered when a single block is updated within a chunk. Use in conjunction with
+  /// MultiBlockUpdate to receive all block updates.
+  public struct SingleBlockUpdate: Event {
     public let position: BlockPosition
     public let newState: Int
-    
+
     public init(position: BlockPosition, newState: Int) {
       self.position = position
       self.newState = newState

Sources/Core/Sources/World/World.swift

@@ -143,7 +143,7 @@ public class World {
       chunk.setBlockId(at: position.relativeToChunk, to: state)
       lightingEngine.updateLighting(at: position, in: self)
 
-      eventBus.dispatch(Event.SetBlock(
+      eventBus.dispatch(Event.SingleBlockUpdate(
         position: position,
         newState: state
       ))
@@ -157,27 +157,36 @@ public class World {
   /// Using this method is preferred over just using setBlockId within a for loop because it
   /// processes lighting updates in batch which is much more efficient.
   /// - Parameters:
-  ///   - chunk: The position of the chunk that all of the updates are in.
   ///   - updates: The positions and new states of affected blocks.
-  public func processMultiBlockChange(
-    at chunkPosition: ChunkPosition,
-    _ updates: [(position: BlockPosition, state: Int)]
+  ///   - chunkPosition: If all updates occur within a single chunk provide this parameter for more
+  ///     efficient batching.
+  public func processMultiBlockUpdate(
+    _ updates: [Event.SingleBlockUpdate],
+    inChunkAt chunkPosition: ChunkPosition? = nil
   ) {
-    if let chunk = chunk(at: chunkPosition) {
-      for (position, state) in updates {
-        chunk.setBlockId(at: position.relativeToChunk, to: state)
-      }
-      lightingEngine.updateLighting(at: updates.map(\.position), in: self)
-
-      for (position, state) in updates {
-        eventBus.dispatch(Event.SetBlock(
-          position: position,
-          newState: state
-        ))
+    if let chunkPosition = chunkPosition {
+      if let chunk = chunk(at: chunkPosition) {
+        for update in updates {
+          chunk.setBlockId(at: update.position.relativeToChunk, to: update.newState)
+        }
+        lightingEngine.updateLighting(at: updates.map(\.position), in: self)
+      } else {
+        log.warning("Cannot handle multi-block change in non-existent chunk, chunkPosition=\(chunkPosition)")
+        return
       }
     } else {
-      log.warning("Cannot handle multi-block change in non-existent chunk, chunkPosition=\(chunkPosition)")
+      for update in updates {
+        if let chunk = chunk(at: update.position.chunk) {
+          chunk.setBlockId(at: update.position.relativeToChunk, to: update.newState)
+        } else {
+          log.warning("Cannot handle multi-block change in non-existent chunk, chunkPosition=\(update.position.chunk)")
+          return
+        }
+      }
+      lightingEngine.updateLighting(at: updates.map(\.position), in: self)
     }
+
+    eventBus.dispatch(Event.MultiBlockUpdate(updates: updates))
   }
 
   /// Get the block id of the block at the specified position.