mirror/Paper
2
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2024-12-15 07:01:36 +08:00
Code Issues Packages Projects Releases Wiki Activity
f21627490e
Paper/Spigot-Server-Patches/0381-Fix-Sending-Chunks-to-Client.patch

67 lines
2.4 KiB
Diff
Raw Normal View History

Cancel pending chunk loads when they are no longer needed This will improve queue times by canceling chunks when a player leaves the radius of an async loading/generating chunk. This matches behavior we had pre 1.13 for loading too.
2018-10-06 12:02:09 +08:00
From f76cc6c38660af7edaf2f57c9b19d8a8353f5703 Mon Sep 17 00:00:00 2001
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
From: Aikar <aikar@aikar.co>
Date: Sat, 29 Sep 2018 01:18:16 -0400
Subject: [PATCH] Fix Sending Chunks to Client
Vanilla has some screwy logic that doesn't send a chunk until
it has been post processed. This is an issue as post processing
doesn't occur until all neighbor chunks have been loaded.
This can reduce view distance while generating terrain, but also
cause bugs where chunks are never sent to the client.
This fix always sends chunks to the client, and simply updates
the client anytime post processing is triggered with the new chunk data.
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
Disable use of Locks on main thread for DataPaletteBlock This should greatly improve performance by using a No Op lock while on the main thread. Vanilla always had a write lock on write operations, but we added a Read Lock during Async Chunks to make concurrent writes non fatal for Async Chunks. This means we added on a bunch of over head to all chunk read operations. This corrects that, as well as disabling the write lock while on main thread. It is a general rule that you do not touch a chunk async once it is loaded into the world, as we never had locks on the chunk before 1.13 even. So once we are on main, we don't expect concurrent access to begin with, so we don't need the write locks either.
2018-10-03 10:29:31 +08:00
index 8da88e1c3a..64cec6d692 100644
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
Disable use of Locks on main thread for DataPaletteBlock This should greatly improve performance by using a No Op lock while on the main thread. Vanilla always had a write lock on write operations, but we added a Read Lock during Async Chunks to make concurrent writes non fatal for Async Chunks. This means we added on a bunch of over head to all chunk read operations. This corrects that, as well as disabling the write lock while on main thread. It is a general rule that you do not touch a chunk async once it is loaded into the world, as we never had locks on the chunk before 1.13 even. So once we are on main, we don't expect concurrent access to begin with, so we don't need the write locks either.
2018-10-03 10:29:31 +08:00
@@ -1213,7 +1213,7 @@ public class Chunk implements IChunkAccess {
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
}
public boolean isReady() {
- return this.C.a(ChunkStatus.POSTPROCESSED);
+ return true; // Paper - Always send chunks
}
public boolean v() {
Disable use of Locks on main thread for DataPaletteBlock This should greatly improve performance by using a No Op lock while on the main thread. Vanilla always had a write lock on write operations, but we added a Read Lock during Async Chunks to make concurrent writes non fatal for Async Chunks. This means we added on a bunch of over head to all chunk read operations. This corrects that, as well as disabling the write lock while on main thread. It is a general rule that you do not touch a chunk async once it is loaded into the world, as we never had locks on the chunk before 1.13 even. So once we are on main, we don't expect concurrent access to begin with, so we don't need the write locks either.
2018-10-03 10:29:31 +08:00
@@ -1479,6 +1479,13 @@ public class Chunk implements IChunkAccess {
[Auto] Updated Upstream (CraftBukkit) Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing CraftBukkit Changes: 68588dac SPIGOT-4405: Chunk generation problem
2018-10-02 21:06:52 +08:00
this.h.clear();
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
this.a(ChunkStatus.POSTPROCESSED);
this.m.a(this);
+ // Paper start - resend chunk after post process
+ PlayerChunk playerChunk = ((WorldServer) world).getPlayerChunkMap().getChunk(locX, locZ);
+ if (playerChunk != null) {
+ playerChunk.done = false;
+ playerChunk.sendAll();
+ }
+ // Paper end
}
}
diff --git a/src/main/java/net/minecraft/server/PlayerChunk.java b/src/main/java/net/minecraft/server/PlayerChunk.java
Cancel pending chunk loads when they are no longer needed This will improve queue times by canceling chunks when a player leaves the radius of an async loading/generating chunk. This matches behavior we had pre 1.13 for loading too.
2018-10-06 12:02:09 +08:00
index 6d18cdeaf7..9584238859 100644
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
--- a/src/main/java/net/minecraft/server/PlayerChunk.java
+++ b/src/main/java/net/minecraft/server/PlayerChunk.java
@@ -23,7 +23,7 @@ public class PlayerChunk {
private int dirtyCount;
private int h;
private long i;
- private boolean done;
+ boolean done; // Paper - package-private
// CraftBukkit start - add fields
// You know the drill, https://hub.spigotmc.org/stash/projects/SPIGOT/repos/craftbukkit/browse
Cancel pending chunk loads when they are no longer needed This will improve queue times by canceling chunks when a player leaves the radius of an async loading/generating chunk. This matches behavior we had pre 1.13 for loading too.
2018-10-06 12:02:09 +08:00
@@ -158,6 +158,7 @@ public class PlayerChunk {
Fix Sending Chunks to Client - Fixes #1504 Vanilla has some screwy logic that doesn't send a chunk until it has been post processed. This is an issue as post processing doesn't occur until all neighbor chunks have been loaded. This can reduce view distance while generating terrain, but also cause bugs where chunks are never sent to the client. This fix always sends chunks to the client, and simply updates the client anytime post processing is triggered with the new chunk data.
2018-09-29 13:22:21 +08:00
}
}
+ public boolean sendAll() { return b(); } // Paper - OBFHELPER
public boolean b() {
if (this.done) {
return true;
--
2.19.0
Reference in New Issue Copy Permalink