chore(rendering): migrate chunk mesh generation Flux

engine/build.gradle

@@ -72,6 +72,7 @@ dependencies {
     implementation "org.terasology:reflections:0.9.12-MB"
     implementation group: 'org.javassist', name: 'javassist', version: '3.27.0-GA'
     implementation group: 'com.esotericsoftware', name: 'reflectasm', version: '1.11.9'
+    implementation group: 'io.reactivex.rxjava3', name: 'rxjava', version: '3.0.13'
 
     // Graphics, 3D, UI, etc
     api platform("org.lwjgl:lwjgl-bom:$LwjglVersion")

engine/src/main/java/org/terasology/engine/core/GameThread.java

@@ -4,9 +4,13 @@
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Queues;
+import io.reactivex.rxjava3.core.Scheduler;
+import io.reactivex.rxjava3.schedulers.Schedulers;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 import java.util.concurrent.BlockingDeque;
+import java.util.concurrent.Executor;
 import java.util.concurrent.Semaphore;
 
 /**
@@ -23,6 +27,21 @@ public final class GameThread {
     private static volatile Thread gameThread;
     private static BlockingDeque<Runnable> pendingRunnables = Queues.newLinkedBlockingDeque();
 
+    private static final Scheduler MAIN;
+
+    static {
+        MAIN = Schedulers.from(new Executor() {
+            @Override
+            public void execute(@NotNull Runnable runnable) {
+                pendingRunnables.add(runnable);
+            }
+        });
+    }
+
+    public static Scheduler main() {
+        return  MAIN;
+    }
+
     private GameThread() {
     }
 

engine/src/main/java/org/terasology/engine/rendering/primitives/ChunkMesh.java

@@ -68,9 +68,6 @@ public enum RenderPhase {
 
     private boolean disposed;
 
-    /* CONCURRENCY */
-    private ReentrantLock lock = new ReentrantLock();
-
     /* MEASUREMENTS */
     private int timeToGenerateBlockVertices;
     private int timeToGenerateOptimizedBuffers;
@@ -95,46 +92,39 @@ public boolean hasVertexElements() {
      * @return True if something was generated
      */
     public boolean generateVBOs() {
-        if (lock.tryLock()) {
-            try {
-                // IMPORTANT: A mesh can only be generated once.
-                if (vertexElements == null || disposed) {
-                    return false;
-                }
 
-                // Make sure that if it has already been generated, the previous buffers are freed
-                dispose();
-                disposed = false;
-
-                for (RenderType type : RenderType.values()) {
-                    generateVBO(type);
-                }
+        // IMPORTANT: A mesh can only be generated once.
+        if (vertexElements == null || disposed) {
+            return false;
+        }
 
-                // Calculate the final amount of triangles
-                triangleCount = (vertexCount[0] + vertexCount[1] + vertexCount[2] + vertexCount[3]) / 3;
-            } finally {
-                lock.unlock();
-            }
+        // Make sure that if it has already been generated, the previous buffers are freed
+        dispose();
+        disposed = false;
 
-            return true;
+        for (RenderType type : RenderType.values()) {
+            generateVBO(type);
         }
 
-        return false;
+        // Calculate the final amount of triangles
+        triangleCount = (vertexCount[0] + vertexCount[1] + vertexCount[2] + vertexCount[3]) / 3;
+
+        return true;
     }
 
     private void generateVBO(RenderType type) {
         VertexElements elements = vertexElements[type.ordinal()];
         int id = type.getIndex();
         if (!disposed && elements.buffer.elements() > 0) {
-            vertexBuffers[id] = GL15.glGenBuffers();
-            idxBuffers[id] = GL15.glGenBuffers();
+            vertexBuffers[id] = GL30.glGenBuffers();
+            idxBuffers[id] = GL30.glGenBuffers();
             vaoCount[id] = GL30.glGenVertexArrays();
 
             GL30.glBindVertexArray(vaoCount[id]);
 
-            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vertexBuffers[id]);
+            GL30.glBindBuffer(GL30.GL_ARRAY_BUFFER, vertexBuffers[id]);
             elements.buffer.writeBuffer(buffer -> {
-                GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL30.GL_STATIC_DRAW);
+                GL30.glBufferData(GL30.GL_ARRAY_BUFFER, buffer, GL30.GL_STATIC_DRAW);
             });
 
             for (VertexResource.VertexDefinition definition : elements.buffer.definitions()) {
@@ -171,19 +161,13 @@ public void discardData() {
     }
 
     private void renderVbo(int id) {
-        if (lock.tryLock()) {
-            try {
-                if (vertexBuffers[id] <= 0 || disposed) {
-                    return;
-                }
-
-                GL30.glBindVertexArray(vaoCount[id]);
-                GL30.glDrawElements(GL30.GL_TRIANGLES, vertexCount[id], GL30.GL_UNSIGNED_INT, 0);
-                GL30.glBindVertexArray(0);
-            } finally {
-                lock.unlock();
-            }
+        if (vertexBuffers[id] <= 0 || disposed) {
+            return;
         }
+
+        GL30.glBindVertexArray(vaoCount[id]);
+        GL30.glDrawElements(GL30.GL_TRIANGLES, vertexCount[id], GL30.GL_UNSIGNED_INT, 0);
+        GL30.glBindVertexArray(0);
     }
 
     /**
@@ -223,33 +207,28 @@ public int render(RenderPhase type) {
      * ChunkMesh instances cannot be un-disposed.
      */
     public void dispose() {
-        lock.lock();
-        try {
-            if (!disposed) {
-                for (int i = 0; i < vertexBuffers.length; i++) {
-                    int id = vertexBuffers[i];
-                    if (id != 0) {
-                        GL15.glDeleteBuffers(id);
-                        vertexBuffers[i] = 0;
-                    }
-
-                    id = idxBuffers[i];
-                    if (id != 0) {
-                        GL15.glDeleteBuffers(id);
-                        idxBuffers[i] = 0;
-                    }
-
-                    id = vaoCount[i];
-                    if (id != 0) {
-                        GL30.glDeleteVertexArrays(id);
-                        vaoCount[i] = 0;
-                    }
+        if (!disposed) {
+            for (int i = 0; i < vertexBuffers.length; i++) {
+                int id = vertexBuffers[i];
+                if (id != 0) {
+                    GL15.glDeleteBuffers(id);
+                    vertexBuffers[i] = 0;
                 }
 
-                disposed = true;
+                id = idxBuffers[i];
+                if (id != 0) {
+                    GL15.glDeleteBuffers(id);
+                    idxBuffers[i] = 0;
+                }
+
+                id = vaoCount[i];
+                if (id != 0) {
+                    GL30.glDeleteVertexArrays(id);
+                    vaoCount[i] = 0;
+                }
             }
-        } finally {
-            lock.unlock();
+
+            disposed = true;
         }
     }
 

engine/src/main/java/org/terasology/engine/rendering/primitives/ChunkTessellator.java

@@ -33,15 +33,11 @@ public ChunkMesh generateMesh(ChunkView chunkView, float scale, int border) {
 
         final Stopwatch watch = Stopwatch.createStarted();
 
-        watch.stop();
-        mesh.setTimeToGenerateBlockVertices((int) watch.elapsed(TimeUnit.MILLISECONDS));
-        watch.reset().start();
-
         // The mesh extends into the borders in the horizontal directions, but not vertically upwards, in order to cover
         // gaps between LOD chunks of different scales, but also avoid multiple overlapping ocean surfaces.
-        for (int x = 0; x < Chunks.SIZE_X; x++) {
+        for (int y = 0; y < Chunks.SIZE_Y - border * 2; y++) {
             for (int z = 0; z < Chunks.SIZE_Z; z++) {
-                for (int y = 0; y < Chunks.SIZE_Y - border * 2; y++) {
+                for (int x = 0; x < Chunks.SIZE_X; x++) {
                     Block block = chunkView.getBlock(x, y, z);
                     if (block != null && block.getMeshGenerator() != null) {
                         block.getMeshGenerator().generateChunkMesh(chunkView, mesh, x, y, z);
@@ -63,7 +59,7 @@ public ChunkMesh generateMesh(ChunkView chunkView, float scale, int border) {
         }
 
         watch.stop();
-        mesh.setTimeToGenerateOptimizedBuffers((int) watch.elapsed(TimeUnit.MILLISECONDS));
+        mesh.setTimeToGenerateBlockVertices((int) watch.elapsed(TimeUnit.MILLISECONDS));
         statVertexArrayUpdateCount++;
 
         PerformanceMonitor.endActivity();