Working on block previews, updated mappings.

build.gradle

@@ -25,7 +25,7 @@ minecraft {
     // stable_#            Stables are built at the discretion of the MCP team.
     // Use non-default mappings at your own risk. they may not always work.
     // Simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: 'snapshot', version: '20200225-1.15.1'
+    mappings channel: 'snapshot', version: '20200514-1.15.1'
     // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
     
     // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
@@ -89,7 +89,7 @@ dependencies {
     // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
     // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
     // The userdev artifact is a special name and will get all sorts of transformations applied to it.
-    minecraft 'net.minecraftforge:forge:1.15.2-31.1.22'
+    minecraft 'net.minecraftforge:forge:1.15.2-31.2.0'
 
     // You may put jars on which you depend on in ./libs or you may define them like so..
     // compile "some.group:artifact:version:classifier"
@@ -127,18 +127,15 @@ jar {
 }
 
 // Example configuration to allow publishing using the maven-publish task
-// we define a custom artifact that is sourced from the reobfJar output task
+// This is the preferred method to reobfuscate your jar file
-// and then declare that to be published
+jar.finalizedBy('reobfJar') 
-// Note you'll need to add a repository here
+// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
-def reobfFile = file("$buildDir/reobfJar/output.jar")
+//publish.dependsOn('reobfJar')
-def reobfArtifact = artifacts.add('default', reobfFile) {
+
-    type 'jar'
-    builtBy 'reobfJar'
-}
 publishing {
     publications {
         mavenJava(MavenPublication) {
-            artifact reobfArtifact
+            artifact jar
         }
     }
     repositories {

src/main/java/nl/requios/effortlessbuilding/item/ItemRandomizerBag.java

@@ -115,7 +115,7 @@ public class ItemRandomizerBag extends Item {
     public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand) {
         ItemStack bag = player.getHeldItem(hand);
 
-        if (player.func_226563_dT_()) {//player.isSneaking()
+        if (player.isSneaking()) {
             if (world.isRemote) return new ActionResult<>(ActionResultType.SUCCESS, bag);
             //Open inventory
             NetworkHooks.openGui((ServerPlayerEntity) player, new ContainerProvider(bag));

src/main/java/nl/requios/effortlessbuilding/proxy/ClientProxy.java

@@ -168,7 +168,7 @@ public class ClientProxy implements IProxy {
 
                 ItemStack currentItemStack = player.getHeldItem(Hand.MAIN_HAND);
                 if (currentItemStack.getItem() instanceof BlockItem ||
-                    (CompatHelper.isItemBlockProxy(currentItemStack) && !player.func_226563_dT_())) { //!player.isSneaking()
+                    (CompatHelper.isItemBlockProxy(currentItemStack) && !player.isSneaking())) {
 
                     ItemStack itemStack = CompatHelper.getItemBlockFromStack(currentItemStack);
 

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

@@ -2,6 +2,7 @@ package nl.requios.effortlessbuilding.render;
 
 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.SoundType;
 import net.minecraft.client.Minecraft;
@@ -78,17 +79,15 @@ public class BlockPreviewRenderer {
         //Render placed blocks with dissolve effect
         //Use fancy shader if config allows, otherwise no dissolve
         if (BuildConfig.visuals.useShaders.get()) {
-            RenderHandler.beginBlockPreviews();
             for (int i = 0; i < placedDataList.size(); i++) {
                 PlacedData placed = placedDataList.get(i);
                 if (placed.coordinates != null && !placed.coordinates.isEmpty()) {
 
                     double totalTime = MathHelper.clampedLerp(30, 60, placed.firstPos.distanceSq(placed.secondPos) / 100.0) * BuildConfig.visuals.dissolveTimeMultiplier.get();
                     float dissolve = (ClientProxy.ticksInGame - placed.time) / (float) totalTime;
-                    renderBlockPreviews(placed.coordinates, placed.blockStates, placed.itemStacks, dissolve, placed.firstPos, placed.secondPos, false, placed.breaking, matrixStack);
+                    renderBlockPreviews(matrixStack, renderTypeBuffer, placed.coordinates, placed.blockStates, placed.itemStacks, dissolve, placed.firstPos, placed.secondPos, false, placed.breaking);
                 }
             }
-            RenderHandler.endBlockPreviews();
         }
         //Expire
         placedDataList.removeIf(placed -> {
@@ -213,25 +212,19 @@ public class BlockPreviewRenderer {
 
                     //Use fancy shader if config allows, otherwise outlines
                     if (BuildConfig.visuals.useShaders.get() && newCoordinates.size() < BuildConfig.visuals.shaderTreshold.get()) {
-
+                        blockCount = renderBlockPreviews(matrixStack, renderTypeBuffer, newCoordinates, blockStates, itemStacks, 0f, firstPos, secondPos, !breaking, breaking);
-                        RenderHandler.beginBlockPreviews();
-
-                        blockCount = renderBlockPreviews(newCoordinates, blockStates, itemStacks, 0f, firstPos, secondPos, !breaking, breaking, matrixStack);
-
-                        RenderHandler.endBlockPreviews();
                     } else {
-
+                        IVertexBuilder buffer = RenderHandler.beginLines(renderTypeBuffer);
-                        RenderHandler.beginLines();
 
                         Vec3d color = new Vec3d(1f, 1f, 1f);
                         if (breaking) color = new Vec3d(1f, 0f, 0f);
 
                         for (int i = newCoordinates.size() - 1; i >= 0; i--) {
                             VoxelShape collisionShape = blockStates.get(i).getCollisionShape(player.world, newCoordinates.get(i));
-                            RenderHandler.renderBlockOutline(newCoordinates.get(i), collisionShape, color, matrixStack);
+                            RenderHandler.renderBlockOutline(matrixStack, buffer, newCoordinates.get(i), collisionShape, color);
                         }
 
-                        RenderHandler.endLines();
+                        RenderHandler.endLines(renderTypeBuffer);
 
                         blockCount = newCoordinates.size();
                     }
@@ -267,7 +260,7 @@ public class BlockPreviewRenderer {
 
             }
 
-            RenderHandler.beginLines();
+            IVertexBuilder buffer = RenderHandler.beginLines(renderTypeBuffer);
             //Draw outlines if tool in hand
             //Find proper raytrace: either normal range or increased range depending on canBreakFar
             RayTraceResult objectMouseOver = Minecraft.getInstance().objectMouseOver;
@@ -285,12 +278,12 @@ public class BlockPreviewRenderer {
                     if (!blockState.getBlock().isAir(blockState, player.world, coordinate)) {
                         if (SurvivalHelper.canBreak(player.world, player, coordinate) || i == 0) {
                             VoxelShape collisionShape = blockState.getCollisionShape(player.world, coordinate);
-                            RenderHandler.renderBlockOutline(coordinate, collisionShape, new Vec3d(0f, 0f, 0f), matrixStack);
+                            RenderHandler.renderBlockOutline(matrixStack, buffer, coordinate, collisionShape, new Vec3d(0f, 0f, 0f));
                         }
                     }
                 }
             }
-            RenderHandler.endLines();
+            RenderHandler.endLines(renderTypeBuffer);
         }
     }
 
@@ -301,9 +294,9 @@ public class BlockPreviewRenderer {
                BuildConfig.visuals.alwaysShowBlockPreview.get();
     }
 
-    protected static int renderBlockPreviews(List<BlockPos> coordinates, List<BlockState> blockStates,
+    protected static int renderBlockPreviews(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, List<BlockPos> coordinates, List<BlockState> blockStates,
                                              List<ItemStack> itemStacks, float dissolve, BlockPos firstPos,
-                                             BlockPos secondPos, boolean checkCanPlace, boolean red, MatrixStack matrixStack) {
+                                             BlockPos secondPos, boolean checkCanPlace, boolean red) {
         PlayerEntity player = Minecraft.getInstance().player;
         ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
         BlockRendererDispatcher dispatcher = Minecraft.getInstance().getBlockRendererDispatcher();
@@ -320,13 +313,13 @@ public class BlockPreviewRenderer {
 
             //Check if can place
             //If check is turned off, check if blockstate is the same (for dissolve effect)
-            if ((!checkCanPlace /*&& player.world.getNewBlockState(blockPos) == blockState*/) || //TODO enable (breaks breaking shader)
+            if ((!checkCanPlace /*&& player.world.getNewBlockState(blockPos) == blockState*/) || //TODO enable (breaks the breaking shader)
                 SurvivalHelper.canPlace(player.world, player, blockPos, blockState, itemstack, modifierSettings.doQuickReplace(), Direction.UP)) {
 
-                ShaderHandler.useShader(ShaderHandler.dissolve, generateShaderCallback(dissolve,
+//                ShaderHandler.useShader(ShaderHandler.dissolve, generateShaderCallback(dissolve,
-                        new Vec3d(blockPos), new Vec3d(firstPos), new Vec3d(secondPos),
+//                        new Vec3d(blockPos), new Vec3d(firstPos), new Vec3d(secondPos),
-                        blockPos == secondPos, red));
+//                        blockPos == secondPos, red));
-                RenderHandler.renderBlockPreview(dispatcher, blockPos, blockState, matrixStack);
+                RenderHandler.renderBlockPreview(matrixStack, renderTypeBuffer, dispatcher, blockPos, blockState);
                 blocksValid++;
             }
         }

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

@@ -4,6 +4,7 @@ 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.texture.AtlasTexture;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
 import org.lwjgl.opengl.GL11;
@@ -14,16 +15,23 @@ public class BuildRenderTypes {
     public static final RenderState.TransparencyState TRANSLUCENT_TRANSPARENCY;
     public static final RenderState.TransparencyState NO_TRANSPARENCY;
 
+    public static final RenderState.DiffuseLightingState DIFFUSE_LIGHTING_ENABLED;
+    public static final RenderState.DiffuseLightingState DIFFUSE_LIGHTING_DISABLED;
+
     public static final RenderState.LayerState PROJECTION_LAYERING;
 
+    public static final RenderState.CullState CULL_DISABLED;
+
+    public static final RenderState.AlphaState DEFAULT_ALPHA;
+
     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;
+    public static final RenderType BLOCK_PREVIEWS;
 
     static {
         TRANSLUCENT_TRANSPARENCY = ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228515_g_");
@@ -36,8 +44,15 @@ public class BuildRenderTypes {
             RenderSystem.defaultBlendFunc();
         });
 
+        DIFFUSE_LIGHTING_ENABLED = new RenderState.DiffuseLightingState(true);
+        DIFFUSE_LIGHTING_DISABLED = new RenderState.DiffuseLightingState(false);
+
         PROJECTION_LAYERING = ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228500_J_");
 
+        CULL_DISABLED = new RenderState.CullState(false);
+
+        DEFAULT_ALPHA = new RenderState.AlphaState(0.003921569F);
+
         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);
@@ -45,12 +60,24 @@ public class BuildRenderTypes {
 
         final int INITIAL_BUFFER_SIZE = 128;
         RenderType.State renderState;
+
+        //LINES
+//        RenderSystem.pushLightingAttributes();
+//        RenderSystem.pushTextureAttributes();
+//        RenderSystem.disableCull();
+//        RenderSystem.disableLighting();
+//        RenderSystem.disableTexture();
+//
+//        RenderSystem.enableBlend();
+//        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+//
+//        RenderSystem.lineWidth(2);
         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))
+                .cull(CULL_DISABLED)
                 .build(false);
         LINES = RenderType.makeType("eb_lines",
                 DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, INITIAL_BUFFER_SIZE, renderState);
@@ -60,10 +87,35 @@ public class BuildRenderTypes {
                 .layer(PROJECTION_LAYERING)
                 .transparency(TRANSLUCENT_TRANSPARENCY)
                 .writeMask(COLOR_WRITE)
-                .cull(new RenderState.CullState(false))
+                .cull(CULL_DISABLED)
                 .build(false);
         PLANES = RenderType.makeType("eb_planes",
                 DefaultVertexFormats.POSITION_COLOR, GL11.GL_TRIANGLE_STRIP, INITIAL_BUFFER_SIZE, renderState);
+
+        //BLOCK PREVIEWS
+//        RenderSystem.pushLightingAttributes();
+//        RenderSystem.pushTextureAttributes();
+//        RenderSystem.enableCull();
+//        RenderSystem.enableTexture();
+//        Minecraft.getInstance().textureManager.bindTexture(ShaderHandler.shaderMaskTextureLocation);
+//
+//        RenderSystem.enableBlend();
+//        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+//        RenderSystem.blendColor(1f, 1f, 1f, 0.8f);
+        //end
+//        ShaderHandler.releaseShader();
+
+        renderState = RenderType.State.getBuilder()
+                .texture(new RenderState.TextureState(AtlasTexture.LOCATION_BLOCKS_TEXTURE, false, false))
+                .transparency(TRANSLUCENT_TRANSPARENCY)
+                .diffuseLighting(DIFFUSE_LIGHTING_DISABLED)
+                .alpha(DEFAULT_ALPHA)
+                .cull(new RenderState.CullState(true))
+                .lightmap(new RenderState.LightmapState(false))
+                .overlay(new RenderState.OverlayState(false))
+                .build(true);
+        BLOCK_PREVIEWS = RenderType.makeType("eb_block_previews",
+                DefaultVertexFormats.BLOCK, GL11.GL_QUADS, INITIAL_BUFFER_SIZE, true, true, renderState);
     }
 
 }

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

@@ -97,7 +97,7 @@ public class ModifierRenderer {
         Matrix4f matrixPos = matrixStack.getLast().getMatrix();
 
         if (drawPlanes) {
-            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
+            IVertexBuilder buffer = RenderHandler.beginPlanes(renderTypeBuffer);
 
             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();
@@ -107,11 +107,11 @@ public class ModifierRenderer {
             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();
 
-            renderTypeBuffer.finish();
+            RenderHandler.endPlanes(renderTypeBuffer);
         }
 
         if (drawLines) {
-            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+            IVertexBuilder buffer = RenderHandler.beginLines(renderTypeBuffer);
 
             Vec3d middle = posA.add(posB).scale(0.5);
             buffer.pos(matrixPos, (float) posA.x, (float) middle.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
@@ -121,7 +121,7 @@ public class ModifierRenderer {
                 buffer.pos(matrixPos, (float) middle.x, (float) posB.y, (float) middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
             }
 
-            renderTypeBuffer.finish();
+            RenderHandler.endLines(renderTypeBuffer);
         }
     }
 
@@ -131,7 +131,7 @@ public class ModifierRenderer {
         Matrix4f matrixPos = matrixStack.getLast().getMatrix();
 
         if (drawPlanes) {
-            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
+            IVertexBuilder buffer = RenderHandler.beginPlanes(renderTypeBuffer);
 
             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();
@@ -141,11 +141,11 @@ public class ModifierRenderer {
             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();
 
-            renderTypeBuffer.finish();
+            RenderHandler.endPlanes(renderTypeBuffer);
         }
 
         if (drawLines) {
-            IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+            IVertexBuilder buffer = RenderHandler.beginLines(renderTypeBuffer);
 
             Vec3d middle = posA.add(posB).scale(0.5);
             buffer.pos(matrixPos, (float) middle.x, (float) middle.y, (float) posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
@@ -153,14 +153,14 @@ public class ModifierRenderer {
             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();
 
-            renderTypeBuffer.finish();
+            RenderHandler.endLines(renderTypeBuffer);
         }
     }
 
     protected static void drawMirrorLines(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, Mirror.MirrorSettings m) {
 
 //        GL11.glColor4d(100, 100, 100, 255);
-        IVertexBuilder buffer = renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
+        IVertexBuilder buffer = RenderHandler.beginLines(renderTypeBuffer);
         Matrix4f matrixPos = matrixStack.getLast().getMatrix();
 
         Vec3d pos = m.position.add(epsilon);
@@ -172,6 +172,6 @@ public class ModifierRenderer {
         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();
 
-        renderTypeBuffer.finish();
+        RenderHandler.endLines(renderTypeBuffer);
     }
 }

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

@@ -1,9 +1,11 @@
 package nl.requios.effortlessbuilding.render;
 
 import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.platform.GlStateManager;
 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;
@@ -13,6 +15,7 @@ import net.minecraft.client.renderer.texture.OverlayTexture;
 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;
@@ -20,9 +23,11 @@ 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;
@@ -49,57 +54,6 @@ public class RenderHandler {
         if(event.getPhase() != EventPriority.NORMAL)
             return;
 
-        // Get instances of the classes required for a block render.
-//        MinecraftServer server = Minecraft.getInstance().getIntegratedServer();
-//        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();
         BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
         IRenderTypeBuffer.Impl renderTypeBuffer = IRenderTypeBuffer.getImpl(bufferBuilder);
@@ -117,26 +71,7 @@ public class RenderHandler {
         ModifierRenderer.render(matrixStack, renderTypeBuffer, modifierSettings);
 
         //Render block previews
-//        BlockPreviewRenderer.render(matrixStack, renderTypeBuffer, player, modifierSettings, modeSettings);
+        BlockPreviewRenderer.render(matrixStack, renderTypeBuffer, player, modifierSettings, modeSettings);
-
-        matrixStack.pop();
-    }
-
-    public static void renderBlock(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, World world, BlockState blockState, BlockPos logicPos, Vec3d projectedView, Vec3d renderCoordinates)
-    {
-        BlockRendererDispatcher blockRendererDispatcher = Minecraft.getInstance().getBlockRendererDispatcher();
-        int i = OverlayTexture.NO_OVERLAY;
-
-        matrixStack.push();
-        matrixStack.translate(-projectedView.x + renderCoordinates.x, -projectedView.y + renderCoordinates.y, -projectedView.z + renderCoordinates.z);
-
-        RenderType renderType = RenderTypeLookup.getRenderType(blockState);
-        renderType = Atlases.getTranslucentBlockType();
-        IBakedModel model = blockRendererDispatcher.getModelForState(blockState);
-        blockRendererDispatcher.getBlockModelRenderer().renderModelBrightnessColor(matrixStack.getLast(), renderTypeBuffer.getBuffer(renderType),
-                blockState, model, 1f, 1f, 1f, 1000, OverlayTexture.NO_OVERLAY);
-//        blockRendererDispatcher.getBlockModelRenderer().renderModel(world, blockRendererDispatcher.getModelForState(blockState),
-//                blockState, logicPos, matrixStack, renderTypeBuffer.getBuffer(renderType), true, new Random(), blockState.getPositionRandom(logicPos), i);
 
         matrixStack.pop();
     }
@@ -223,101 +158,85 @@ public class RenderHandler {
         }
     }
 
-    protected static void beginLines() {
+    protected static IVertexBuilder beginLines(IRenderTypeBuffer.Impl renderTypeBuffer) {
-//        RenderSystem.pushLightingAttributes();
+        return renderTypeBuffer.getBuffer(BuildRenderTypes.LINES);
-//        RenderSystem.pushTextureAttributes();
-//        RenderSystem.disableCull();
-//        RenderSystem.disableLighting();
-//        RenderSystem.disableTexture();
-//
-//        RenderSystem.enableBlend();
-//        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-//
-//        RenderSystem.lineWidth(2);
     }
 
-    protected static void endLines() {
+    protected static void endLines(IRenderTypeBuffer.Impl renderTypeBuffer) {
-//        RenderSystem.popAttributes();
+        renderTypeBuffer.finish();
     }
 
-    protected static void beginBlockPreviews() {
+    protected static IVertexBuilder beginPlanes(IRenderTypeBuffer.Impl renderTypeBuffer){
-        RenderSystem.pushLightingAttributes();
+        return renderTypeBuffer.getBuffer(BuildRenderTypes.PLANES);
-        RenderSystem.pushTextureAttributes();
-        RenderSystem.enableCull();
-        RenderSystem.enableTexture();
-//        Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
-        Minecraft.getInstance().textureManager.bindTexture(ShaderHandler.shaderMaskTextureLocation);
-
-        RenderSystem.enableBlend();
-        RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        RenderSystem.blendColor(1f, 1f, 1f, 0.8f);
     }
 
-    protected static void endBlockPreviews() {
+    protected static void endPlanes(IRenderTypeBuffer.Impl renderTypeBuffer){
-        ShaderHandler.releaseShader();
+        renderTypeBuffer.finish();
-        RenderSystem.disableBlend();
-
-        RenderSystem.popAttributes();
     }
 
-    protected static void renderBlockPreview(BlockRendererDispatcher dispatcher, BlockPos blockPos, BlockState blockState, MatrixStack matrixStack) {
+    protected static IVertexBuilder beginBlockPreviews(IRenderTypeBuffer.Impl renderTypeBuffer) {
+//        return renderTypeBuffer.getBuffer(Atlases.getTranslucentBlockType());
+        return renderTypeBuffer.getBuffer(BuildRenderTypes.BLOCK_PREVIEWS);
+    }
+
+    protected static void endBlockPreviews(IRenderTypeBuffer.Impl renderTypeBuffer) {
+        renderTypeBuffer.finish();
+    }
+
+    protected static void renderBlockPreview(MatrixStack matrixStack, IRenderTypeBuffer.Impl renderTypeBuffer, BlockRendererDispatcher dispatcher, BlockPos blockPos, BlockState blockState) {
         if (blockState == null) return;
 
-        RenderSystem.pushMatrix();
+        matrixStack.push();
-        RenderSystem.translatef(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+        matrixStack.translate(blockPos.getX(), blockPos.getY(), blockPos.getZ());
-        RenderSystem.rotatef(-90.0F, 0.0F, 1.0F, 0.0F);
+//        matrixStack.rotate(Vector3f.YP.rotationDegrees(-90f));
-        RenderSystem.translatef(-0.01f, -0.01f, 0.01f);
+        matrixStack.translate(-0.01f, -0.01f, -0.01f);
-        RenderSystem.scalef(1.02f, 1.02f, 1.02f);
+        matrixStack.scale(1.02f, 1.02f, 1.02f);
+
+        IVertexBuilder buffer = RenderHandler.beginBlockPreviews(renderTypeBuffer);
+//        RenderType renderType = RenderTypeLookup.getRenderType(blockState);
+//        MinecraftServer server = Minecraft.getInstance().getIntegratedServer();
+//        World world = DimensionManager.getWorld(server, DimensionType.OVERWORLD, false, true);
 
-        //TODO 1.15
         try {
-            IRenderTypeBuffer.Impl bufferSource = Minecraft.getInstance().getRenderTypeBuffers().getBufferSource();
+            IBakedModel model = dispatcher.getModelForState(blockState);
-            dispatcher.renderBlock(blockState, matrixStack, bufferSource, 1, 1);
+            dispatcher.getBlockModelRenderer().renderModelBrightnessColor(matrixStack.getLast(), buffer,
-            bufferSource.finish();
+                    blockState, model, 1f, 1f, 1f, 0, OverlayTexture.NO_OVERLAY);
-//            dispatcher.renderBlockBrightness(blockState, 0.85f);
+//        blockRendererDispatcher.getBlockModelRenderer().renderModel(world, blockRendererDispatcher.getModelForState(blockState),
+//                blockState, logicPos, matrixStack, renderTypeBuffer.getBuffer(renderType), true, new Random(), blockState.getPositionRandom(logicPos), i);
         } catch (NullPointerException e) {
             EffortlessBuilding.logger.warn("RenderHandler::renderBlockPreview cannot render " + blockState.getBlock().toString());
 
-            //Render outline as backup
+            //Render outline as backup, escape out of the current renderstack
-            RenderSystem.popMatrix();
+            matrixStack.pop();
-//            ShaderHandler.releaseShader();
+            endBlockPreviews(renderTypeBuffer);
-            GL11.glDisable(GL11.GL_LIGHTING);
+            IVertexBuilder lineBuffer = beginLines(renderTypeBuffer);
-            renderBlockOutline(blockPos, new Vec3d(1f, 1f, 1f), matrixStack);
+            renderBlockOutline(matrixStack, lineBuffer, blockPos, new Vec3d(1f, 1f, 1f));
-            GL11.glEnable(GL11.GL_LIGHTING);
+            endLines(renderTypeBuffer);
-            RenderSystem.pushMatrix();
+            buffer = beginBlockPreviews(renderTypeBuffer);
+            matrixStack.push();
         }
 
-        RenderSystem.popMatrix();
+        endBlockPreviews(renderTypeBuffer);
+
+        matrixStack.pop();
     }
 
-    protected static void renderBlockOutline(BlockPos pos, Vec3d color, MatrixStack matrixStack) {
+    protected static void renderBlockOutline(MatrixStack matrixStack, IVertexBuilder buffer, BlockPos pos, Vec3d color) {
-        renderBlockOutline(pos, pos, color, matrixStack);
+        renderBlockOutline(matrixStack, buffer, pos, pos, color);
     }
 
     //Renders outline. Pos1 has to be minimal x,y,z and pos2 maximal x,y,z
-    protected static void renderBlockOutline(BlockPos pos1, BlockPos pos2, Vec3d color, MatrixStack matrixStack) {
+    protected static void renderBlockOutline(MatrixStack matrixStack, IVertexBuilder buffer, BlockPos pos1, BlockPos pos2, Vec3d color) {
-        RenderSystem.lineWidth(2);
-
         AxisAlignedBB aabb = new AxisAlignedBB(pos1, pos2.add(1, 1, 1)).grow(0.0020000000949949026);
 
-        //TODO 1.15
-        IVertexBuilder buffer = Minecraft.getInstance().getRenderTypeBuffers().getBufferSource().getBuffer(RenderType.LINES);
         WorldRenderer.drawBoundingBox(matrixStack, buffer, aabb, (float) color.x, (float) color.y, (float) color.z, 0.4f);
 //        WorldRenderer.drawSelectionBoundingBox(aabb, (float) color.x, (float) color.y, (float) color.z, 0.4f);
     }
 
     //Renders outline with given bounding box
-    protected static void renderBlockOutline(BlockPos pos, VoxelShape collisionShape, Vec3d color, MatrixStack matrixStack) {
+    protected static void renderBlockOutline(MatrixStack matrixStack, IVertexBuilder buffer, BlockPos pos, VoxelShape collisionShape, Vec3d color) {
-        RenderSystem.lineWidth(2);
-
-//        AxisAlignedBB aabb = boundingBox.offset(pos).grow(0.0020000000949949026);
-//        VoxelShape voxelShape = collisionShape.withOffset(pos.getX(), pos.getY(), pos.getZ());
-
-//        WorldRenderer.drawSelectionBoundingBox(aabb, (float) color.x, (float) color.y, (float) color.z, 0.4f);
-        //TODO 1.15
-        IVertexBuilder buffer = Minecraft.getInstance().getRenderTypeBuffers().getBufferSource().getBuffer(RenderType.LINES);
-        WorldRenderer.drawVoxelShapeParts(matrixStack, buffer, collisionShape, pos.getX(), pos.getY(), pos.getZ(), (float) color.x, (float) color.y, (float) color.z, 0.4f);
 //        WorldRenderer.drawShape(collisionShape, pos.getX(), pos.getY(), pos.getZ(), (float) color.x, (float) color.y, (float) color.z, 0.4f);
+        WorldRenderer.drawVoxelShapeParts(matrixStack, buffer, collisionShape, pos.getX(), pos.getY(), pos.getZ(), (float) color.x, (float) color.y, (float) color.z, 0.4f);
     }
 
     //TODO 1.14