Modifier rendering complete (lines and planes)

src/main/java/nl/requios/effortlessbuilding/render/BlockPreviewRenderer.java

@@ -7,6 +7,7 @@ import net.minecraft.block.SoundType;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.player.ClientPlayerEntity;
 import net.minecraft.client.renderer.BlockRendererDispatcher;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
 import net.minecraft.client.renderer.texture.AtlasTexture;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
@@ -72,7 +73,7 @@ public class BlockPreviewRenderer {
     private static final int primaryTextureUnit = 0;
     private static final int secondaryTextureUnit = 2;
 
-    public static void render(PlayerEntity player, ModifierSettings modifierSettings, ModeSettings modeSettings, MatrixStack matrixStack) {
+    public static void render(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, PlayerEntity player, ModifierSettings modifierSettings, ModeSettings modeSettings) {
 
         //Render placed blocks with dissolve effect
         //Use fancy shader if config allows, otherwise no dissolve

src/main/java/nl/requios/effortlessbuilding/render/BuildRenderTypes.java

@@ -0,0 +1,69 @@
+package nl.requios.effortlessbuilding.render;
+
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
+import net.minecraft.client.renderer.RenderState;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
+import org.lwjgl.opengl.GL11;
+
+import java.util.OptionalDouble;
+
+public class BuildRenderTypes {
+    public static final RenderState.TransparencyState TRANSLUCENT_TRANSPARENCY;
+    public static final RenderState.TransparencyState NO_TRANSPARENCY;
+
+    public static final RenderState.LayerState PROJECTION_LAYERING;
+
+    public static final RenderState.WriteMaskState WRITE_TO_DEPTH_AND_COLOR;
+    public static final RenderState.WriteMaskState COLOR_WRITE;
+
+    public static final RenderState.TransparencyState MY_TRANSPARENCY;
+
+    public static final RenderType LINES;
+
+    public static final RenderType PLANES;
+
+    static {
+        TRANSLUCENT_TRANSPARENCY = ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228515_g_");
+        NO_TRANSPARENCY = ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228510_b_");
+        MY_TRANSPARENCY = new RenderState.TransparencyState("eb_transparency", () -> {
+            RenderSystem.enableBlend();
+            RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
+        }, () -> {
+            RenderSystem.disableBlend();
+            RenderSystem.defaultBlendFunc();
+        });
+
+        PROJECTION_LAYERING = ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228500_J_");
+
+        final boolean ENABLE_DEPTH_WRITING = true;
+        final boolean ENABLE_COLOUR_COMPONENTS_WRITING = true;
+        WRITE_TO_DEPTH_AND_COLOR = new RenderState.WriteMaskState(ENABLE_COLOUR_COMPONENTS_WRITING, ENABLE_DEPTH_WRITING);
+        COLOR_WRITE = new RenderState.WriteMaskState(true, false);
+
+        final int INITIAL_BUFFER_SIZE = 128;
+        RenderType.State renderState;
+        renderState = RenderType.State.getBuilder()
+                .line(new RenderState.LineState(OptionalDouble.of(2)))
+                .layer(PROJECTION_LAYERING)
+                .transparency(TRANSLUCENT_TRANSPARENCY)
+                .writeMask(WRITE_TO_DEPTH_AND_COLOR)
+                .cull(new RenderState.CullState(false))
+                .build(false);
+        LINES = RenderType.makeType("eb_lines",
+                DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, INITIAL_BUFFER_SIZE, renderState);
+
+        renderState = RenderType.State.getBuilder()
+                .line(new RenderState.LineState(OptionalDouble.of(2)))
+                .layer(PROJECTION_LAYERING)
+                .transparency(TRANSLUCENT_TRANSPARENCY)
+                .writeMask(COLOR_WRITE)
+                .cull(new RenderState.CullState(false))
+                .build(false);
+        PLANES = RenderType.makeType("eb_planes",
+                DefaultVertexFormats.POSITION_COLOR, GL11.GL_TRIANGLE_STRIP, INITIAL_BUFFER_SIZE, renderState);
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/render/ModifierRenderer.java

@@ -1,7 +1,10 @@
 package nl.requios.effortlessbuilding.render;
 
 import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
 import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.Matrix4f;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.util.math.Vec3d;
@@ -25,9 +28,7 @@ public class ModifierRenderer {
     protected static final int planeAlpha = 75;
     protected static final Vec3d epsilon = new Vec3d(0.001, 0.001, 0.001); //prevents z-fighting
 
-    public static void render(ModifierSettingsManager.ModifierSettings modifierSettings, MatrixStack matrixStack) {
+    public static void render(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, ModifierSettingsManager.ModifierSettings modifierSettings) {
-        RenderHandler.beginLines();
-
         //Mirror lines and areas
         Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
         if (m != null && m.enabled && (m.mirrorX || m.mirrorY || m.mirrorZ))
@@ -40,28 +41,28 @@ public class ModifierRenderer {
                 Vec3d posA = new Vec3d(pos.x, pos.y - radius, pos.z - radius);
                 Vec3d posB = new Vec3d(pos.x, pos.y + radius, pos.z + radius);
 
-                drawMirrorPlane(posA, posB, colorX, m.drawLines, m.drawPlanes, true);
+                drawMirrorPlane(matrixStack, renderTypeBuffer, posA, posB, colorX, m.drawLines, m.drawPlanes, true);
             }
             if (m.mirrorY)
             {
                 Vec3d posA = new Vec3d(pos.x - radius, pos.y, pos.z - radius);
                 Vec3d posB = new Vec3d(pos.x + radius, pos.y, pos.z + radius);
 
-                drawMirrorPlaneY(posA, posB, colorY, m.drawLines, m.drawPlanes);
+                drawMirrorPlaneY(matrixStack, renderTypeBuffer, posA, posB, colorY, m.drawLines, m.drawPlanes);
             }
             if (m.mirrorZ)
             {
                 Vec3d posA = new Vec3d(pos.x - radius, pos.y - radius, pos.z);
                 Vec3d posB = new Vec3d(pos.x + radius, pos.y + radius, pos.z);
 
-                drawMirrorPlane(posA, posB, colorZ, m.drawLines, m.drawPlanes, true);
+                drawMirrorPlane(matrixStack, renderTypeBuffer, posA, posB, colorZ, m.drawLines, m.drawPlanes, true);
             }
 
             //Draw axis coordinated colors if two or more axes are enabled
             //(If only one is enabled the lines are that planes color)
             if (m.drawLines && ((m.mirrorX && m.mirrorY) || (m.mirrorX && m.mirrorZ) || (m.mirrorY && m.mirrorZ)))
             {
-                drawMirrorLines(m);
+                drawMirrorLines(matrixStack, renderTypeBuffer, m);
             }
         }
 
@@ -82,96 +83,95 @@ public class ModifierRenderer {
 
                 Vec3d posA = new Vec3d(pos.x, pos.y - radius, pos.z);
                 Vec3d posB = new Vec3d(newVec.x, pos.y + radius, newVec.z);
-                drawMirrorPlane(posA, posB, colorRadial, r.drawLines, r.drawPlanes, false);
+                drawMirrorPlane(matrixStack, renderTypeBuffer, posA, posB, colorRadial, r.drawLines, r.drawPlanes, false);
             }
         }
-
-        RenderHandler.endLines();
     }
 
 
     //----Mirror----
 
-    protected static void drawMirrorPlane(Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes, boolean drawVerticalLines) {
+    protected static void drawMirrorPlane(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes, boolean drawVerticalLines) {
 
-        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha);
+//        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha);
-        Tessellator tessellator = Tessellator.getInstance();
+        Matrix4f matrixPos = matrixStack.getLast().getMatrix();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
 
         if (drawPlanes) {
-            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
+            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
 
-            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posA.x, posB.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posB.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) posA.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posB.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) posB.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            //backface (using triangle strip)
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posB.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
 
-            tessellator.draw();
+            renderTypeBuffer.finish();
         }
 
         if (drawLines) {
-            Vec3d middle = posA.add(posB).scale(0.5);
+            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
-            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
 
-            bufferBuilder.pos(posA.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            Vec3d middle = posA.add(posB).scale(0.5);
-            bufferBuilder.pos(posB.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) middle.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) middle.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
             if (drawVerticalLines) {
-                bufferBuilder.pos(middle.x, posA.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+                buffer.pos(matrixPos, (float) middle.x, (float) posA.y, (float) middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-                bufferBuilder.pos(middle.x, posB.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+                buffer.pos(matrixPos, (float) middle.x, (float) posB.y, (float) middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
             }
 
-            tessellator.draw();
+            renderTypeBuffer.finish();
         }
     }
 
-    protected static void drawMirrorPlaneY(Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes) {
+    protected static void drawMirrorPlaneY(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes) {
 
-        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha());
+//        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha());
-        Tessellator tessellator = Tessellator.getInstance();
+        Matrix4f matrixPos = matrixStack.getLast().getMatrix();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
 
         if (drawPlanes) {
-            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
+            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
 
-            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posA.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) posA.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            //backface (using triangle strip)
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
 
-            tessellator.draw();
+            renderTypeBuffer.finish();
         }
 
         if (drawLines) {
+            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+
             Vec3d middle = posA.add(posB).scale(0.5);
-            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
+            buffer.pos(matrixPos, (float) middle.x, (float) middle.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            buffer.pos(matrixPos, (float) middle.x, (float) middle.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posA.x, (float) middle.y, (float) middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            buffer.pos(matrixPos, (float) posB.x, (float) middle.y, (float) middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
 
-            bufferBuilder.pos(middle.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            renderTypeBuffer.finish();
-            bufferBuilder.pos(middle.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(posA.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(posB.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-
-            tessellator.draw();
         }
     }
 
-    protected static void drawMirrorLines(Mirror.MirrorSettings m) {
+    protected static void drawMirrorLines(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, Mirror.MirrorSettings m) {
+
+//        GL11.glColor4d(100, 100, 100, 255);
+        IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+        Matrix4f matrixPos = matrixStack.getLast().getMatrix();
 
         Vec3d pos = m.position.add(epsilon);
 
-        GL11.glColor4d(100, 100, 100, 255);
+        buffer.pos(matrixPos, (float) pos.x - m.radius, (float) pos.y, (float) pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-        GL11.glLineWidth(2);
+        buffer.pos(matrixPos, (float) pos.x + m.radius, (float) pos.y, (float) pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-        Tessellator tessellator = Tessellator.getInstance();
+        buffer.pos(matrixPos, (float) pos.x, (float) pos.y - m.radius, (float) pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
+        buffer.pos(matrixPos, (float) pos.x, (float) pos.y + m.radius, (float) pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
+        buffer.pos(matrixPos, (float) pos.x, (float) pos.y, (float) pos.z - m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
+        buffer.pos(matrixPos, (float) pos.x, (float) pos.y, (float) pos.z + m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
 
-        bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
+        renderTypeBuffer.finish();
-
-        bufferBuilder.pos(pos.x - m.radius, pos.y, pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x + m.radius, pos.y, pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y - m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y + m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y, pos.z - m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y, pos.z + m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
-
-        tessellator.draw();
     }
 }

src/main/java/nl/requios/effortlessbuilding/render/RenderHandler.java

@@ -4,19 +4,15 @@ import com.mojang.blaze3d.matrix.MatrixStack;
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.vertex.IVertexBuilder;
 import net.minecraft.block.BlockState;
-import net.minecraft.block.Blocks;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.audio.SimpleSound;
 import net.minecraft.client.entity.player.ClientPlayerEntity;
 import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.model.IBakedModel;
 import net.minecraft.client.renderer.texture.OverlayTexture;
-import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.SoundCategory;
 import net.minecraft.util.SoundEvents;
 import net.minecraft.util.math.AxisAlignedBB;
@@ -24,11 +20,9 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.world.World;
-import net.minecraft.world.dimension.DimensionType;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.common.DimensionManager;
 import net.minecraftforge.eventbus.api.EventPriority;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
@@ -43,11 +37,6 @@ import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
 import nl.requios.effortlessbuilding.network.PacketHandler;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL14;
-
-import java.awt.*;
-import java.util.OptionalDouble;
-import java.util.Random;
 
 /***
  * Main render class for Effortless Building
@@ -55,84 +44,82 @@ import java.util.Random;
 @Mod.EventBusSubscriber(value = Dist.CLIENT)
 public class RenderHandler {
 
-    protected static final RenderState.LayerState PROJECTION_LAYERING = new RenderState.LayerState("projection_layering", () -> {
-        RenderSystem.matrixMode(5889);
-        RenderSystem.pushMatrix();
-        RenderSystem.scalef(1.0F, 1.0F, 0.999F);
-        RenderSystem.matrixMode(5888);
-    }, () -> {
-        RenderSystem.matrixMode(5889);
-        RenderSystem.popMatrix();
-        RenderSystem.matrixMode(5888);
-    });
-    protected static final RenderState.TransparencyState TRANSLUCENT_TRANSPARENCY = new RenderState.TransparencyState("translucent_transparency", () -> {
-        RenderSystem.enableBlend();
-        RenderSystem.defaultBlendFunc();
-    }, () -> {
-        RenderSystem.disableBlend();
-    });
-    protected static final RenderState.WriteMaskState COLOR_WRITE = new RenderState.WriteMaskState(true, false);
-
-    public static final RenderType PLANES = RenderType.makeType("planes", DefaultVertexFormats.POSITION_COLOR, GL11.GL_TRIANGLE_STRIP, 256, RenderType.State.getBuilder().line(new RenderState.LineState(OptionalDouble.empty())).layer(PROJECTION_LAYERING).transparency(TRANSLUCENT_TRANSPARENCY).writeMask(COLOR_WRITE).build(false));
-
     @SubscribeEvent
     public static void onRender(RenderWorldLastEvent event) {
         if(event.getPhase() != EventPriority.NORMAL)
             return;
 
         // Get instances of the classes required for a block render.
-        MinecraftServer server = Minecraft.getInstance().getIntegratedServer();
+//        MinecraftServer server = Minecraft.getInstance().getIntegratedServer();
-        World world = DimensionManager.getWorld(server, DimensionType.OVERWORLD, false, true);
+//        World world = DimensionManager.getWorld(server, DimensionType.OVERWORLD, false, true);
+//        MatrixStack matrixStack = event.getMatrixStack();
+//
+//        // Get the projected view coordinates.
+//        Vec3d projectedView = Minecraft.getInstance().gameRenderer.getActiveRenderInfo().getProjectedView();
+//
+//        // Choose obsidian as the arbitrary block.
+//        BlockState blockState = Blocks.BIRCH_LOG.getDefaultState();
+//
+//        // Begin rendering the block.
+//        BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
+//        IRenderTypeBuffer.Impl renderTypeBuffer = IRenderTypeBuffer.getImpl(bufferBuilder);
+//
+//        renderBlock(matrixStack, renderTypeBuffer, world, blockState, new BlockPos(0, 68, 0), projectedView, new Vec3d(0.0, 68.0, 0.0));
+//
+//        renderTypeBuffer.finish();
+//
+////TEST lines
+//
+//        matrixStack.push();
+//        matrixStack.translate(-projectedView.x, -projectedView.y, -projectedView.z);
+//        IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
+//
+//        Matrix4f matrixPos = matrixStack.getLast().getMatrix();
+//        Vec3d posA = new Vec3d(-10, 64, -10);
+//        Vec3d posB = new Vec3d(10, 70, 10);
+//        Color c = new Color(255, 72, 52);
+//        int planeAlpha = 200;
+//        buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+//        buffer.pos(matrixPos, (float) posA.x, (float) posB.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+//        buffer.pos(matrixPos, (float) posB.x, (float) posA.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+//        buffer.pos(matrixPos, (float) posB.x, (float) posB.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+//
+//        renderTypeBuffer.finish();
+//
+//        //Test lines
+//        buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+//
+//        matrixPos = matrixStack.getLast().getMatrix();
+//        posA = new Vec3d(-10, 64, -10);
+//        posB = new Vec3d(10, 70, 10);
+//        int lineAlpha = 255;
+//        buffer.pos(matrixPos, (float) posA.x, (float) posA.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+//        buffer.pos(matrixPos, (float) posB.x, (float) posB.y, (float) posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+//
+//        renderTypeBuffer.finish();
+//        matrixStack.pop();
+
+
         MatrixStack matrixStack = event.getMatrixStack();
-
-        // Get the projected view coordinates.
-        Vec3d projectedView = Minecraft.getInstance().gameRenderer.getActiveRenderInfo().getProjectedView();
-
-        // Choose obsidian as the arbitrary block.
-        BlockState blockState = Blocks.BIRCH_LOG.getDefaultState();
-
-        // Begin rendering the block.
         BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
         IRenderTypeBuffer.Impl renderTypeBuffer = IRenderTypeBuffer.getImpl(bufferBuilder);
 
-        renderBlock(matrixStack, renderTypeBuffer, world, blockState, new BlockPos(0, 128, 0), projectedView, new Vec3d(0.0, 128.0, 0.0));
+        PlayerEntity player = Minecraft.getInstance().player;
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
 
-        renderTypeBuffer.finish();
+        Vec3d projectedView = Minecraft.getInstance().gameRenderer.getActiveRenderInfo().getProjectedView();
-
-//TEST lines
 
         matrixStack.push();
-        Vec3d pos = new Vec3d(0, 0, 0);
+        matrixStack.translate(-projectedView.x, -projectedView.y, -projectedView.z);
-        matrixStack.translate(-projectedView.x + pos.x, -projectedView.y + pos.y, -projectedView.z + pos.z);
-        IVertexBuilder buffer = renderTypeBuffer.getBuffer(PLANES);
-//        bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
 
-        Vec3d posA = new Vec3d(-10, 128, -10);
+        //Mirror and radial mirror lines and areas
-        Vec3d posB = new Vec3d(10, 120, 10);
+        ModifierRenderer.render(matrixStack, renderTypeBuffer, modifierSettings);
-        Color c = new Color(255, 72, 52);
+
-        int planeAlpha = 75;
+        //Render block previews
-        buffer.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+//        BlockPreviewRenderer.render(matrixStack, renderTypeBuffer, player, modifierSettings, modeSettings);
-        buffer.pos(posA.x, posB.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-        buffer.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-        buffer.pos(posB.x, posB.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
 
         matrixStack.pop();
-        renderTypeBuffer.finish();
-
-
-//        PlayerEntity player = Minecraft.getInstance().player;
-//        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-//        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-//
-//        begin(event.getPartialTicks(), event.getMatrixStack());
-//
-//        //Mirror and radial mirror lines and areas
-//        ModifierRenderer.render(modifierSettings, event.getMatrixStack());
-//
-//        //Render block previews
-//        BlockPreviewRenderer.render(player, modifierSettings, modeSettings, event.getMatrixStack());
-//
-//        end(event.getMatrixStack());
     }
 
     public static void renderBlock(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, World world, BlockState blockState, BlockPos logicPos, Vec3d projectedView, Vec3d renderCoordinates)
@@ -236,42 +223,25 @@ public class RenderHandler {
         }
     }
 
-    private static void begin(float partialTicks, MatrixStack matrixStack) {
-//        PlayerEntity player = Minecraft.getInstance().player;
-//        double playerX = player.prevPosX + (player.posX - player.prevPosX) * partialTicks;
-//        double playerY = player.prevPosY + (player.posY - player.prevPosY) * partialTicks;
-//        double playerZ = player.prevPosZ + (player.posZ - player.prevPosZ) * partialTicks;
-//        Vec3d playerPos = new Vec3d(playerX, playerY, playerZ);
-
-        matrixStack.push();
-//        RenderSystem.pushMatrix();
-//        GL11.glTranslated(-playerPos.x, -playerPos.y, -playerPos.z);
-        //TODO 1.15
-//        Vec3d projectedView = Minecraft.getInstance().getRenderManager().info.getProjectedView();
-//        RenderSystem.translated(-projectedView.x, -projectedView.y, -projectedView.z);
-
-        RenderSystem.depthMask(false);
-    }
-
     protected static void beginLines() {
-        RenderSystem.pushLightingAttributes(); //GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+//        RenderSystem.pushLightingAttributes();
-        RenderSystem.pushTextureAttributes();
+//        RenderSystem.pushTextureAttributes();
-        RenderSystem.disableCull();
+//        RenderSystem.disableCull();
-        RenderSystem.disableLighting();
+//        RenderSystem.disableLighting();
-        RenderSystem.disableTexture();
+//        RenderSystem.disableTexture();
-
+//
-        RenderSystem.enableBlend();
+//        RenderSystem.enableBlend();
-        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+//        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-
+//
-        RenderSystem.lineWidth(2);
+//        RenderSystem.lineWidth(2);
     }
 
     protected static void endLines() {
-        RenderSystem.popAttributes();
+//        RenderSystem.popAttributes();
     }
 
     protected static void beginBlockPreviews() {
-        RenderSystem.pushLightingAttributes(); //GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+        RenderSystem.pushLightingAttributes();
         RenderSystem.pushTextureAttributes();
         RenderSystem.enableCull();
         RenderSystem.enableTexture();
@@ -290,11 +260,6 @@ public class RenderHandler {
         RenderSystem.popAttributes();
     }
 
-    private static void end(MatrixStack matrixStack) {
-        RenderSystem.depthMask(true);
-        matrixStack.pop();
-    }
-
     protected static void renderBlockPreview(BlockRendererDispatcher dispatcher, BlockPos blockPos, BlockState blockState, MatrixStack matrixStack) {
         if (blockState == null) return;