Changed the algorithm responsible for dynamic chunk updates to be bas…

…ed on actual FPS, instead of estimated vsync idle time. Works more reliably.
andrewphorn · Oct 21, 2014 · f68c6a4 · f68c6a4
1 parent 0883784
commit f68c6a4
Show file tree

Hide file tree

Showing 3 changed files with 18 additions and 26 deletions.
diff --git a/src/main/java/com/mojang/minecraft/Minecraft.java b/src/main/java/com/mojang/minecraft/Minecraft.java
@@ -96,7 +96,6 @@
 import com.mojang.util.StreamingUtil;
 import com.mojang.util.Timer;
 import com.mojang.util.Vec3D;
-import java.text.DecimalFormat;
 
 public final class Minecraft implements Runnable {
 
@@ -883,6 +882,7 @@ private void onFrame() {
             // Get current time in seconds 
             double now = System.nanoTime() / Timer.NANOSEC_PER_SEC;
             double secondsPassed = (now - timer.lastHR);
+            timer.lastFrameDuration = secondsPassed;
             timer.lastHR = now;
 
             // Cap seconds-passed to range [0,1]
@@ -1095,33 +1095,28 @@ private void onFrame() {
                             // Calculate the limit on chunk-updates-per-frame
                             int maxUpdates;
                             if (settings.limitFramerate) {
-                                maxUpdates = Math.max(Renderer.dynamicChunkUpdateLimit, Renderer.MIN_CHUNK_UPDATES_PER_FRAME);
+                                maxUpdates = Math.max(renderer.dynamicChunkUpdateLimit, renderer.MIN_CHUNK_UPDATES_PER_FRAME);
                             } else {
                                 maxUpdates = Renderer.MIN_CHUNK_UPDATES_PER_FRAME;
                             }
                             chunkUpdates = Math.min(chunkUpdates, maxUpdates);
 
                             // Actually update the chunks. Measure how long it takes.
-                            long timeBeforeChunkUpdates = System.nanoTime();
                             for (int i = 0; i < chunkUpdates; ++i) {
                                 Chunk chunk = levelRenderer.chunksToUpdate.remove(lastChunkId - i);
                                 chunk.update();
                                 chunk.loaded = false;
                             }
-                            long chunkUpdateTime = System.nanoTime() - timeBeforeChunkUpdates;
 
-                            // Adjust measured average-time-per-chunk-update
-                            timer.chunkUpdateTime = timer.chunkUpdateTime * 0.5
-                                    + (chunkUpdateTime / Timer.NANOSEC_PER_SEC / chunkUpdates) * 0.5;
-
-                            // Next frame, use up to 90% of available CPU time for chunks
-                            Renderer.dynamicChunkUpdateLimit = (int) Math.floor(timer.syncTime / timer.chunkUpdateTime * 0.9);
-
-                            DecimalFormat formatter = new DecimalFormat("#0.00000");
-                            LogUtil.logInfo("sT=" + formatter.format(timer.syncTime)
-                                    + " | cUT=" + formatter.format(timer.chunkUpdateTime)
-                                    + " | dCUL=" + Renderer.dynamicChunkUpdateLimit
-                                    + " | mU=" + maxUpdates);
+                            // Adjust chunks-per-frame based on framerate. Back off is under 30fps.
+                            if(timer.lastFrameDuration > 1/30d ){
+                                renderer.everBackedOffFromChunkUpdates=(renderer.dynamicChunkUpdateLimit>renderer.MIN_CHUNK_UPDATES_PER_FRAME);
+                                renderer.dynamicChunkUpdateLimit = Math.max(Renderer.MIN_CHUNK_UPDATES_PER_FRAME, renderer.dynamicChunkUpdateLimit-=2);
+                            }else if(renderer.everBackedOffFromChunkUpdates){
+                                renderer.dynamicChunkUpdateLimit+=1;
+                            }else{
+                                renderer.dynamicChunkUpdateLimit+=3;
+                            }
                         }
 
                         // Mark fog-obscured chunks as invisible
@@ -1437,10 +1432,7 @@ private void onFrame() {
                     }
 
                     Thread.yield();
-                    long timeBeforeSync = System.nanoTime();
                     Display.update();
-                    long syncNanosecs = System.nanoTime() - timeBeforeSync;
-                    timer.syncTime = timer.syncTime * .5 + (syncNanosecs / Timer.NANOSEC_PER_SEC) * .5;
                 }
             }
 

diff --git a/src/main/java/com/mojang/minecraft/render/Renderer.java b/src/main/java/com/mojang/minecraft/render/Renderer.java
@@ -20,10 +20,11 @@
 import org.lwjgl.opengl.GL11;
 
 public final class Renderer {
-
+    // Chunk update timing
     public static final int MIN_CHUNK_UPDATES_PER_FRAME = 4;
-    public static int dynamicChunkUpdateLimit = MIN_CHUNK_UPDATES_PER_FRAME;
-
+    public int dynamicChunkUpdateLimit = MIN_CHUNK_UPDATES_PER_FRAME;
+    public boolean everBackedOffFromChunkUpdates= false;
+
     public Minecraft minecraft;
     public float fogColorMultiplier = 1F;
     public boolean displayActive = false;

diff --git a/src/main/java/com/mojang/util/Timer.java b/src/main/java/com/mojang/util/Timer.java
@@ -4,18 +4,17 @@ public class Timer {
     public static final double NANOSEC_PER_SEC = 1000000000D;
     public float tps;
 
+    public double firstHR;
     public double lastHR;
     public int elapsedTicks;
     public float delta;
     public float speed = 1F;
     public float elapsedDelta = 0F;
-    public long lastHRClock;
 
-    public double syncTime;
-    public double chunkUpdateTime;
+    public double lastFrameDuration;
 
     public Timer(float tps) {
         this.tps = tps;
-        lastHRClock = System.nanoTime() / 1000000L;
+        this.firstHR = System.nanoTime()/NANOSEC_PER_SEC;
     }
 }