- JEI compatibility for Structure Preview, and many, many widget library changes...

- The mixin was introduced, so we now need the MixinBooter to use the mod.
- Added a new prefix attribute for machinery, which will be rendered to the left of the title in the preview screen.
- Bump version.

Author: KasumiNova

build.gradle.kts

@@ -12,7 +12,7 @@ plugins {
 
 // Project properties
 group = "hellfirepvp.modularmachinery"
-version = "1.12.2-1.11.1-r56-dev"
+version = "2.0.0-pre1"
 
 // Set the toolchain version to decouple the Java we run Gradle with from the Java used to compile and run the mod
 java {
@@ -40,7 +40,14 @@ minecraft {
     // tagReplacementFiles.add("RfgExampleMod.java")
 
     // Enable assertions in the mod's package when running the client or server
-    extraRunJvmArguments.add("-ea:${project.group}")
+    val args = mutableListOf("-ea:${project.group}")
+
+    // Mixin args
+    args.add("-Dfml.coreMods.load=github.kasuminova.mmce.mixin.MMCEEarlyMixinLoader")
+    args.add("-Dmixin.hotSwap=true")
+    args.add("-Dmixin.checks.interfaces=true")
+    args.add("-Dmixin.debug.export=true")
+    extraRunJvmArguments.addAll(args)
 
     // If needed, add extra tweaker classes like for mixins.
     // extraTweakClasses.add("org.spongepowered.asm.launch.MixinTweaker")
@@ -73,6 +80,14 @@ tasks.compileJava.configure {
     }
 }
 
+tasks.jar.configure {
+    manifest {
+        val attributes = manifest.attributes
+        attributes["FMLCorePlugin"] = "github.kasuminova.mmce.mixin.MMCEEarlyMixinLoader"
+        attributes["FMLCorePluginContainsFMLMod"] = true
+    }
+}
+
 tasks.javadoc.configure {
     // No need for JavaDoc.
     actions = Collections.emptyList()
@@ -151,7 +166,16 @@ dependencies {
     testCompileOnly("me.eigenraven.java8unsupported:java-8-unsupported-shim:1.0.0")
 
     // Mixins
-    implementation("zone.rong:mixinbooter:7.1")
+    val mixin : String = modUtils.enableMixins("zone.rong:mixinbooter:8.9", "mixins.mmce.refmap.json").toString()
+    api (mixin) {
+        isTransitive = false
+    }
+    annotationProcessor("org.ow2.asm:asm-debug-all:5.2")
+    annotationProcessor("com.google.guava:guava:30.0-jre")
+    annotationProcessor("com.google.code.gson:gson:2.8.9")
+    annotationProcessor (mixin) {
+        isTransitive = false
+    }
 
     implementation("CraftTweaker2:CraftTweaker2-MC1120-Main:1.12-4.+")
     implementation(rfg.deobf("curse.maven:had-enough-items-557549:4810661"))

src/main/java/com/cleanroommc/client/preview/renderer/scene/WorldSceneRenderer.java

@@ -3,6 +3,9 @@
 import com.cleanroommc.client.util.*;
 import com.cleanroommc.client.util.world.LRDummyWorld;
 import github.kasuminova.mmce.client.util.BufferBuilderPool;
+import it.unimi.dsi.fastutil.objects.Object2IntArrayMap;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
@@ -33,6 +36,7 @@
 import java.nio.IntBuffer;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
@@ -56,7 +60,17 @@ public abstract class WorldSceneRenderer {
 
     protected static final AtomicInteger THREAD_ID = new AtomicInteger(0);
 
-    protected Map<BlockRenderLayer, BufferBuilder> layerBufferBuilders = new EnumMap<>(BlockRenderLayer.class);
+    protected static final Object2IntMap<BlockRenderLayer> LAYER_PROGRESS_UNITS = new Object2IntOpenHashMap<>();
+
+    protected volatile Map<BlockRenderLayer, BufferBuilder> layerBufferBuilders = new EnumMap<>(BlockRenderLayer.class);
+
+    static {
+        LAYER_PROGRESS_UNITS.defaultReturnValue(1);
+        LAYER_PROGRESS_UNITS.put(BlockRenderLayer.SOLID, 4);
+        LAYER_PROGRESS_UNITS.put(BlockRenderLayer.CUTOUT_MIPPED, 1);
+        LAYER_PROGRESS_UNITS.put(BlockRenderLayer.CUTOUT, 3);
+        LAYER_PROGRESS_UNITS.put(BlockRenderLayer.TRANSLUCENT, 2);
+    }
 
     enum CacheState {
         UNUSED,
@@ -88,7 +102,7 @@ enum CacheState {
 
     public WorldSceneRenderer(LRDummyWorld world) {
         this.dummyWorld = world;
-        renderedBlocksMap = new LRMap<>(new LinkedHashMap<>(), new LinkedHashMap<>());
+        renderedBlocksMap = new LRMap<>(new ConcurrentHashMap<>(), new ConcurrentHashMap<>());
         cacheState = new AtomicReference<>(CacheState.UNUSED);
     }
 
@@ -101,10 +115,7 @@ public WorldSceneRenderer useCacheBuffer(boolean useCache) {
                 this.vertexBuffers.getBuffer()[j] = new VertexBuffer(DefaultVertexFormats.BLOCK);
                 this.vertexBuffers.getAnotherBuffer()[j] = new VertexBuffer(DefaultVertexFormats.BLOCK);
             }
-            if (cacheState.get() == CacheState.COMPILING && thread != null) {
-                thread.interrupt();
-                thread = null;
-            }
+            stopCompileCache();
             cacheState.set(CacheState.NEED);
         }
         this.useCache = useCache;
@@ -114,16 +125,16 @@ public WorldSceneRenderer useCacheBuffer(boolean useCache) {
     public WorldSceneRenderer deleteCacheBuffer() {
         if (useCache) {
             Thread thread = this.thread;
-            if (cacheState.get() == CacheState.COMPILING && this.thread != null) {
-                this.thread.interrupt();
-                this.thread = null;
-            }
+            stopCompileCache();
 
             VertexBuffer[] bufferRef = this.vertexBuffers.getBuffer();
             VertexBuffer[] anotherBufferRef = this.vertexBuffers.getAnotherBuffer();
             this.vertexBuffers.setLeft(null);
             this.vertexBuffers.setRight(null);
 
+            Map<BlockRenderLayer, BufferBuilder> layerBufferBuilders = this.layerBufferBuilders;
+            this.layerBufferBuilders = new EnumMap<>(BlockRenderLayer.class);
+
             CompletableFuture.runAsync(() -> {
                 if (thread != null && thread.isAlive()) {
                     try {
@@ -152,14 +163,22 @@ public WorldSceneRenderer deleteCacheBuffer() {
     }
 
     public WorldSceneRenderer needCompileCache() {
-        if (cacheState.get() == CacheState.COMPILING && thread != null) {
-            thread.interrupt();
-            thread = null;
+        if (useCache) {
+            stopCompileCache();
+            cacheState.set(CacheState.NEED);
+        } else {
+            switchLRRenderer(Minecraft.getMinecraft());
         }
-        cacheState.set(CacheState.NEED);
         return this;
     }
 
+    public void stopCompileCache() {
+        if (cacheState.get() == CacheState.COMPILING) {
+            cacheState.set(CacheState.UNUSED);
+            thread.interrupt();
+        }
+    }
+
     public WorldSceneRenderer setBeforeWorldRender(Consumer<WorldSceneRenderer> callback) {
         this.beforeRender = callback;
         return this;
@@ -364,11 +383,22 @@ public boolean isCompiling() {
         return cacheState.get() == CacheState.COMPILING;
     }
 
-    public double getCompileProgress() {
-        if (maxProgress > 1000) {
-            return progress.get() * 1. / maxProgress;
+    public boolean isCompilerThreadAlive() {
+        if (thread != null) {
+            if (thread.isAlive()) {
+                return true;
+            }
+            thread = null;
+        }
+        return false;
+    }
+
+    public float getCompileProgress() {
+        // 1000 blocks, 11 is per block unit.
+        if (maxProgress <= 1000 * 11) {
+            return -1;
         }
-        return 0;
+        return (float) progress.get() / maxProgress;
     }
 
     public World getWorld() {
@@ -403,19 +433,21 @@ public WorldSceneRenderer setVertexBuffers(VertexBuffer[] vertexBuffers) {
     }
 
     public void refreshCache() {
-        if (cacheState.get() == CacheState.COMPILING) {
+        if (isCompiling() || isCompilerThreadAlive()) {
             return;
         }
         cacheState.set(CacheState.COMPILING);
         progress.set(0);
-        maxProgress = renderedBlocksMap.getAnotherMap().keySet().stream().map(Collection::size).reduce(0, Integer::sum) * (BlockRenderLayer.values().length + 1);
+        maxProgress = renderedBlocksMap.getAnotherMap().keySet().stream()
+                .map(Collection::size)
+                .reduce(0, Integer::sum) * 11;
 
         BlockRenderLayer oldRenderLayer = MinecraftForgeClient.getRenderLayer();
         Minecraft mc = Minecraft.getMinecraft();
         boolean checkDisabledModel = getWorld() == mc.world || (getWorld() instanceof TrackedDummyWorld && ((TrackedDummyWorld) getWorld()).proxyWorld == mc.world);
 
         thread = new Thread(() -> compileCache(mc, oldRenderLayer, checkDisabledModel));
-        thread.setName("PreviewCompiler-" + THREAD_ID.getAndIncrement());
+        thread.setName("MMCE-PreviewCompiler-" + THREAD_ID.getAndIncrement());
         thread.start();
     }
 
@@ -428,7 +460,7 @@ protected void renderDefault(final Minecraft mc, final float particleTicks, fina
                 if (pass == 1) {
                     renderTESR(0, particleTicks, checkDisabledModel);
                 }
-                renderedBlocksMap.getMap().forEach((renderedBlocks, hook)->{
+                renderedBlocksMap.getMap().forEach((renderedBlocks, hook) -> {
                     if (hook != null) {
                         hook.apply(false, pass, layer);
                     } else {
@@ -437,7 +469,7 @@ protected void renderDefault(final Minecraft mc, final float particleTicks, fina
                     BufferBuilder buffer = Tessellator.getInstance().getBuffer();
                     buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
 
-                    renderBlocks(checkDisabledModel, blockrendererdispatcher, layer, buffer, renderedBlocks, getWorld());
+                    renderBlocks(checkDisabledModel, blockrendererdispatcher, layer, buffer, renderedBlocks, getWorld(), 0);
 
                     Tessellator.getInstance().draw();
                     Tessellator.getInstance().getBuffer().setTranslation(0, 0, 0);
@@ -451,14 +483,7 @@ protected void renderDefault(final Minecraft mc, final float particleTicks, fina
 
     protected void renderCacheBuffer(Minecraft mc, BlockRenderLayer oldRenderLayer, float particleTicks, boolean checkDisabledModel) {
         if (cacheState.get() == CacheState.NEED) {
-            cacheState.set(CacheState.COMPILING);
-            progress.set(0);
-            maxProgress = renderedBlocksMap.getAnotherMap().keySet().stream()
-                    .map(Collection::size)
-                    .reduce(0, Integer::sum) * (BlockRenderLayer.values().length + 1);
-
-            thread = new Thread(() -> compileCache(mc, oldRenderLayer, checkDisabledModel));
-            thread.start();
+            refreshCache();
         }
         for (BlockRenderLayer layer : BlockRenderLayer.values()) {
             int pass = layer == BlockRenderLayer.TRANSLUCENT ? 1 : 0;
@@ -508,19 +533,20 @@ private void compileCache(final Minecraft mc, final BlockRenderLayer oldRenderLa
         Thread compilerThread = Thread.currentThread();
         BlockRendererDispatcher blockrendererdispatcher = mc.getBlockRendererDispatcher();
         Map<Collection<BlockPos>, ISceneRenderHook> renderedBlocksMap = this.renderedBlocksMap.getAnotherMap();
-        Arrays.stream(BlockRenderLayer.values()).parallel().forEach(layer -> {
+        for (final BlockRenderLayer layer : BlockRenderLayer.values()) {
+            int progressUnit = LAYER_PROGRESS_UNITS.get(layer);
             ForgeHooksClient.setRenderLayer(layer);
             BufferBuilder buffer = getLayerBufferBuilder(layer);
             synchronized (buffer) {
                 buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
                 for (final Collection<BlockPos> renderedBlocks : renderedBlocksMap.keySet()) {
-                    renderBlocks(checkDisabledModel, blockrendererdispatcher, layer, buffer, renderedBlocks, getLRDummyWorld().getAnotherWorld());
+                    renderBlocks(checkDisabledModel, blockrendererdispatcher, layer, buffer, renderedBlocks, getLRDummyWorld().getAnotherWorld(), progressUnit);
                 }
                 buffer.finishDrawing();
                 buffer.reset();
             }
             ForgeHooksClient.setRenderLayer(null);
-            if (compilerThread.isInterrupted()) {
+            if (!isCompiling()) {
                 return;
             }
             mc.addScheduledTask(() -> {
@@ -530,15 +556,15 @@ private void compileCache(final Minecraft mc, final BlockRenderLayer oldRenderLa
                 ByteBuffer buf = buffer.getByteBuffer();
                 vertexBuffers.getAnotherBuffer()[layer.ordinal()].bufferData(buf);
             });
-        });
-        if (compilerThread.isInterrupted()) {
+        }
+        if (!isCompiling()) {
             return;
         }
         Set<BlockPos> poses = new HashSet<>();
         renderedBlocksMap.forEach((renderedBlocks, hook) -> {
             for (BlockPos pos : renderedBlocks) {
                 progress.getAndIncrement();
-                if (compilerThread.isInterrupted()) {
+                if (!isCompiling()) {
                     return;
                 }
 //                        if (checkDisabledModel && MultiblockWorldSavedData.modelDisabled.contains(pos)) {
@@ -550,32 +576,36 @@ private void compileCache(final Minecraft mc, final BlockRenderLayer oldRenderLa
                 }
             }
         });
-        if (compilerThread.isInterrupted()) {
+        if (!isCompiling()) {
             return;
         }
 
         tileEntities = poses;
         cacheState.set(CacheState.COMPILED);
-        thread = null;
         maxProgress = -1;
 
+        switchLRRenderer(mc);
+
+        thread = null;
+    }
+
+    protected void switchLRRenderer(final Minecraft mc) {
         dummyWorld.setUseLeft(!dummyWorld.isUseLeft());
         vertexBuffers.setUseLeft(!vertexBuffers.isUseLeft());
-        this.renderedBlocksMap.setUseLeft(!this.renderedBlocksMap.isUseLeft());
-        mc.addScheduledTask(() -> {
-            this.renderedBlocksMap.getAnotherMap().clear();
-        });
+        renderedBlocksMap.setUseLeft(!renderedBlocksMap.isUseLeft());
+        renderedBlocksMap.getAnotherMap().clear();
     }
 
     private void renderBlocks(final boolean checkDisabledModel,
                               final BlockRendererDispatcher rendererDispatcher,
                               final BlockRenderLayer layer,
                               final BufferBuilder buffer,
                               final Collection<BlockPos> renderedBlocks,
-                              final World world) {
+                              final World world,
+                              final int progressUnit) {
         for (BlockPos pos : renderedBlocks) {
             if (maxProgress > 0) {
-                progress.getAndIncrement();
+                progress.getAndAdd(progressUnit);
             }
 //            if (checkDisabledModel && MultiblockWorldSavedData.modelDisabled.contains(pos)) {
 //                continue;
@@ -636,7 +666,6 @@ private void renderTESR(final int pass, float particle, boolean checkDisabledMod
         }
         ForgeHooksClient.setRenderPass(-1);
         RenderHelper.disableStandardItemLighting();
-
     }
 
     public static void setDefaultPassRenderState(int pass) {

src/main/java/com/cleanroommc/client/util/RenderUtils.java

@@ -20,7 +20,7 @@ public static void renderBlockOverLay(BlockPos pos, float r, float g, float b, f
         GlStateManager.disableTexture2D();
         BufferBuilder buffer = tessellator.getBuffer();
         buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
-        com.cleanroommc.multiblocked.client.util.RenderUtils.renderCubeFace(buffer, -0.5f, -0.5f, -0.5f, 0.5, 0.5, 0.5, r, g, b, a);
+        RenderUtils.renderCubeFace(buffer, -0.5f, -0.5f, -0.5f, 0.5, 0.5, 0.5, r, g, b, a);
         tessellator.draw();
 
         GlStateManager.scale(1 / scale, 1 / scale, 1 / scale);
@@ -31,4 +31,35 @@ public static void renderBlockOverLay(BlockPos pos, float r, float g, float b, f
         GlStateManager.color(1, 1, 1, 1);
     }
 
+    public static void renderCubeFace(BufferBuilder buffer, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float r, float g, float b, float a) {
+        buffer.pos(minX, minY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, minY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, maxY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, maxY, minZ).color(r, g, b, a).endVertex();
+
+        buffer.pos(maxX, minY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, minY, maxZ).color(r, g, b, a).endVertex();
+
+        buffer.pos(minX, minY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, minY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, minY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, minY, maxZ).color(r, g, b, a).endVertex();
+
+        buffer.pos(minX, maxY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, maxY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, minZ).color(r, g, b, a).endVertex();
+
+        buffer.pos(minX, minY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, maxY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, minZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, minY, minZ).color(r, g, b, a).endVertex();
+
+        buffer.pos(minX, minY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, minY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(maxX, maxY, maxZ).color(r, g, b, a).endVertex();
+        buffer.pos(minX, maxY, maxZ).color(r, g, b, a).endVertex();
+    }
 }

src/main/java/github/kasuminova/mmce/client/gui/GuiContainerDynamic.java

@@ -49,7 +49,7 @@ public void onGuiClosed() {
 
     @Override
     protected void drawGuiContainerBackgroundLayer(final float partialTicks, final int mouseX, final int mouseY) {
-        widgetController.render(new MousePos(mouseX, mouseY));
+        widgetController.render(new MousePos(mouseX, mouseY), true);
     }
 
     @Override