Bugfixing and Blaze solver

9 files changed, 573 insertions, 277 deletions

diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/Boxes.java b/src/main/java/me/xmrvizzy/skyblocker/utils/Boxes.java
new file mode 100644
index 00000000..445bcbe5
--- /dev/null
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/Boxes.java
@@ -0,0 +1,47 @@
+package me.xmrvizzy.skyblocker.utils;
+
+
+import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Direction.Axis;
+import net.minecraft.util.math.Vec3d;
+
+public class Boxes {
+
+    /** Returns the vector of the min pos of this box. **/
+    public static Vec3d getMinVec(Box box) {
+        return new Vec3d(box.minX, box.minY, box.minZ);
+    }
+
+    /** Returns the vector of the max pos of this box. **/
+    public static Vec3d getMaxVec(Box box) {
+        return new Vec3d(box.maxX, box.maxY, box.maxZ);
+    }
+
+    /** Offsets this box so that minX, minY and minZ are all zero. **/
+    public static Box moveToZero(Box box) {
+        return box.offset(getMinVec(box).negate());
+    }
+
+    /** Returns the distance between to oppisite corners of the box. **/
+    public static double getCornerLength(Box box) {
+        return getMinVec(box).distanceTo(getMaxVec(box));
+    }
+
+    /** Returns the length of an axis in the box. **/
+    public static double getAxisLength(Box box, Axis axis) {
+        return box.getMax(axis) - box.getMin(axis);
+    }
+
+    /** Returns a box with each axis multiplied by the amount specified. **/
+    public static Box multiply(Box box, double amount) {
+        return multiply(box, amount, amount, amount);
+    }
+
+    /** Returns a box with each axis multiplied by the amount specified. **/
+    public static Box multiply(Box box, double x, double y, double z) {
+        return box.expand(
+                getAxisLength(box, Axis.X) * (x - 1) / 2d,
+                getAxisLength(box, Axis.Y) * (y - 1) / 2d,
+                getAxisLength(box, Axis.Z) * (z - 1) / 2d);
+    }
+}
diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/FrustumUtils.java b/src/main/java/me/xmrvizzy/skyblocker/utils/FrustumUtils.java
new file mode 100644
index 00000000..6973aa1e
--- /dev/null
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/FrustumUtils.java
@@ -0,0 +1,17 @@
+package me.xmrvizzy.skyblocker.utils;
+
+import me.xmrvizzy.skyblocker.mixin.AccessorWorldRenderer;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.util.math.Box;
+
+public class FrustumUtils {
+
+    public static Frustum getFrustum() {
+        return ((AccessorWorldRenderer) MinecraftClient.getInstance().worldRenderer).getFrustum();
+    }
+
+    public static boolean isBoxVisible(Box box) {
+        return getFrustum().isVisible(box);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtils.java b/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtils.java
index 472c41d6..05044ba0 100644
--- a/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtils.java
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtils.java
@@ -1,224 +1,89 @@
 package me.xmrvizzy.skyblocker.utils;
 
-import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
 
+import me.xmrvizzy.skyblocker.utils.color.QuadColor;
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.*;
-import net.minecraft.client.render.block.entity.BlockEntityRenderDispatcher;
+import net.minecraft.client.render.BufferBuilder;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.GameRenderer;
+import net.minecraft.client.render.Tessellator;
+import net.minecraft.client.render.VertexFormat;
+import net.minecraft.client.render.VertexFormats;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Direction;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL14;
+import net.minecraft.util.math.Vec3f;
 
 public class RenderUtils {
 
-    public static void drawFilledBox(BlockPos blockPos, float r, float g, float b, float a) {
-        drawFilledBox(new Box(blockPos), r, g, b, a);
-    }
-
-    public static void drawFilledBox(Box box, float r, float g, float b, float a) {
-        gl11Setup();
-
-        // Fill
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder buffer = tessellator.getBuffer();
 
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        buffer.begin(drawMode, VertexFormats.POSITION_COLOR);
 
-//        buffer.begin(5, VertexFormats.POSITION_COLOR);
-        WorldRenderer.drawBox(buffer,
-                box.minX, box.minY, box.minZ,
-                box.maxX, box.maxY, box.maxZ, r, g, b, a / 2f);
-        tessellator.draw();
+    // -------------------- Outline Boxes --------------------
 
-        // Outline
-        buffer.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        buffer.begin(3, VertexFormats.POSITION_COLOR);
-        buffer.vertex(box.minX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.maxZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.minX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.maxZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.maxX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.minZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.maxX, box.maxY, box.minZ).color(r, g, b, a).next();
-        tessellator.draw();
-
-        gl11Cleanup();
-    }
-
-    public static void drawOutlineBox(BlockPos blockPos, float r, float g, float b, float a) {
-        drawOutlineBox(new Box(blockPos), r, g, b, a);
-    }
-
-    public static void fillGradient(MatrixStack matrix, int x1, int y1, int x2, int y2, int color1, int color2) {
-        float float_1 = (color1 >> 24 & 255) / 255.0F;
-        float float_2 = (color1 >> 16 & 255) / 255.0F;
-        float float_3 = (color1 >> 8 & 255) / 255.0F;
-        float float_4 = (color1 & 255) / 255.0F;
-        float float_5 = (color2 >> 24 & 255) / 255.0F;
-        float float_6 = (color2 >> 16 & 255) / 255.0F;
-        float float_7 = (color2 >> 8 & 255) / 255.0F;
-        float float_8 = (color2 & 255) / 255.0F;
-        Tessellator tessellator_1 = Tessellator.getInstance();
-        BufferBuilder bufferBuilder_1 = tessellator_1.getBuffer();
-
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        bufferBuilder_1.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        bufferBuilder_1.begin(7, VertexFormats.POSITION_COLOR);
-        bufferBuilder_1.vertex(x1, y1, 0).color(float_2, float_3, float_4, float_1).next();
-        bufferBuilder_1.vertex(x1, y2, 0).color(float_2, float_3, float_4, float_1).next();
-        bufferBuilder_1.vertex(x2, y2, 0).color(float_6, float_7, float_8, float_5).next();
-        bufferBuilder_1.vertex(x2, y1, 0).color(float_6, float_7, float_8, float_5).next();
-        tessellator_1.draw();
-    }
+    public static void drawBoxOutline(Box box, QuadColor color, float lineWidth, Direction... excludeDirs) {
+        if (!FrustumUtils.isBoxVisible(box)) {
+            return;
+        }
 
+        setup();
 
-    public static void drawOutlineBox(Box box, float r, float g, float b, float a) {
-        gl11Setup();
+        MatrixStack matrices = matrixFrom(box.minX, box.minY, box.minZ);
 
         Tessellator tessellator = Tessellator.getInstance();
         BufferBuilder buffer = tessellator.getBuffer();
 
         // Outline
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        buffer.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        buffer.begin(3, VertexFormats.POSITION_COLOR);
-        buffer.vertex(box.minX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.maxY, box.minZ).color(r, g, b, a).next();
-        buffer.vertex(box.minX, box.minY, box.maxZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.minX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.maxZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.maxX, box.maxY, box.maxZ).color(r, g, b, a).next();
-        buffer.vertex(box.maxX, box.minY, box.minZ).color(r, g, b, 0f).next();
-        buffer.vertex(box.maxX, box.maxY, box.minZ).color(r, g, b, a).next();
-        tessellator.draw();
-
-        gl11Cleanup();
-    }
-
-    public static void drawLine(double x1, double y1, double z1, double x2, double y2, double z2, float r, float g, float b, float t) {
-        gl11Setup();
-        GL11.glLineWidth(t);
+        RenderSystem.disableCull();
+        RenderSystem.setShader(GameRenderer::getRenderTypeLinesShader);
+        RenderSystem.lineWidth(lineWidth);
 
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder buffer = tessellator.getBuffer();
-
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        buffer.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        buffer.begin(3, VertexFormats.POSITION_COLOR);
-        buffer.vertex(x1, y1, z1).color(r, g, b, 0.0F).next();
-        buffer.vertex(x1, y1, z1).color(r, g, b, 1.0F).next();
-        buffer.vertex(x2, y2, z2).color(r, g, b, 1.0F).next();
+        buffer.begin(VertexFormat.DrawMode.LINES, VertexFormats.LINES);
+        Vertexer.vertexBoxLines(matrices, buffer, Boxes.moveToZero(box), color, excludeDirs);
         tessellator.draw();
 
-        gl11Cleanup();
+        RenderSystem.enableCull();
 
+        cleanup();
     }
 
-    public static void drawRect(float x, float y, float w, float h, int color, float alpha) {
-        float red = (float) (color >> 16 & 255) / 255.0F;
-        float green = (float) (color >> 8 & 255) / 255.0F;
-        float blue = (float) (color & 255) / 255.0F;
-        final Tessellator tessellator = Tessellator.getInstance();
-        final BufferBuilder bufferbuilder = tessellator.getBuffer();
-        GlStateManager._enableBlend();
-        GlStateManager._disableTexture();
-        GlStateManager._blendFuncSeparate(770, 771, 1, 0);
-
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        bufferbuilder.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        bufferbuilder.begin(7, VertexFormats.POSITION_COLOR);
-        bufferbuilder.vertex(x, h, 0.0D).color(red, green, blue, alpha).next();
-        bufferbuilder.vertex(w, h, 0.0D).color(red, green, blue, alpha).next();
-        bufferbuilder.vertex(w, y, 0.0D).color(red, green, blue, alpha).next();
-        bufferbuilder.vertex(x, y, 0.0D).color(red, green, blue, alpha).next();
-        tessellator.draw();
-        GlStateManager._enableTexture();
-        GlStateManager._disableBlend();
-    }
+    // -------------------- Utils --------------------
+
+    public static MatrixStack matrixFrom(double x, double y, double z) {
+        MatrixStack matrices = new MatrixStack();
 
-    public static void offsetRender() {
-        //debg
         Camera camera = MinecraftClient.getInstance().gameRenderer.getCamera();
-        Vec3d camPos = camera.getPos();
-        GL11.glRotated(MathHelper.wrapDegrees(camera.getPitch()), 1, 0, 0);
-        GL11.glRotated(MathHelper.wrapDegrees(camera.getYaw() + 180.0), 0, 1, 0);
-        GL11.glTranslated(-camPos.x, -camPos.y, -camPos.z);
-    }
+        matrices.multiply(Vec3f.POSITIVE_X.getDegreesQuaternion(camera.getPitch()));
+        matrices.multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(camera.getYaw() + 180.0F));
 
-    public static void gl11Setup() {
-        GL11.glPushMatrix();
-        GL11.glEnable(GL11.GL_BLEND);
-        GL14.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
-        GL11.glLineWidth(2.5F);
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-        GL11.glEnable(GL11.GL_LINE_SMOOTH);
-        offsetRender();
-    }
+        matrices.translate(x - camera.getPos().x, y - camera.getPos().y, z - camera.getPos().z);
 
-    public static void gl11Cleanup() {
-        GL11.glDisable(GL11.GL_LINE_SMOOTH);
-        GL11.glEnable(GL11.GL_TEXTURE_2D);
-        GL11.glDisable(GL11.GL_BLEND);
-        GL11.glPopMatrix();
+        return matrices;
     }
 
+    public static Vec3d getInterpolationOffset(Entity e) {
+        if (MinecraftClient.getInstance().isPaused()) {
+            return Vec3d.ZERO;
+        }
 
-    public static void DrawPolygon(double x, double y, int radius, int sides, int color) {
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-
-        final Tessellator tessellator = Tessellator.getInstance();
-        final BufferBuilder bufferbuilder = tessellator.getBuffer();
-
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.TRIANGLE_FAN;
-        bufferbuilder.begin(drawMode, VertexFormats.POSITION_COLOR);
-
-//        bufferbuilder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION);
-
-        float alpha = (float) (color >> 24 & 255) / 255.0F;
-        float red = (float) (color >> 16 & 255) / 255.0F;
-        float green = (float) (color >> 8 & 255) / 255.0F;
-        float blue = (float) (color & 255) / 255.0F;
-
-        bufferbuilder.vertex(x, y, 0).next();
-        final double TWICE_PI = Math.PI * 2;
+        double tickDelta = (double) MinecraftClient.getInstance().getTickDelta();
+        return new Vec3d(
+                e.getX() - MathHelper.lerp(tickDelta, e.lastRenderX, e.getX()),
+                e.getY() - MathHelper.lerp(tickDelta, e.lastRenderY, e.getY()),
+                e.getZ() - MathHelper.lerp(tickDelta, e.lastRenderZ, e.getZ()));
+    }
 
-        for (int i = 0; i <= sides; i++) {
-            double angle = (TWICE_PI * i / sides) + Math.toRadians(180);
-            bufferbuilder.vertex(x + Math.sin(angle) * radius, y + Math.cos(angle) * radius, 0).next();
-        }
-        tessellator.draw();
+    public static void setup() {
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.disableTexture();
+    }
 
-        GL11.glEnable(GL11.GL_TEXTURE_2D);
-        GL11.glDisable(GL11.GL_BLEND);
+    public static void cleanup() {
+        RenderSystem.disableBlend();
+        RenderSystem.enableTexture();
     }
 }
\ No newline at end of file
diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtilsLiving.java b/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtilsLiving.java
index 6fca52a0..f6fb1bc1 100644
--- a/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtilsLiving.java
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/RenderUtilsLiving.java
@@ -19,124 +19,127 @@ package me.xmrvizzy.skyblocker.utils;
  */
 
 
+import java.lang.reflect.Field;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.BufferBuilder;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.DiffuseLighting;
+import net.minecraft.client.render.OverlayTexture;
 import net.minecraft.client.render.Tessellator;
-import net.minecraft.client.render.VertexFormat;
-import net.minecraft.client.render.VertexFormats;
-import net.minecraft.client.render.model.json.ModelTransformation.Mode;
-import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.model.json.ModelTransformation;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.enchantment.Enchantment;
-import net.minecraft.enchantment.EnchantmentHelper;
-import net.minecraft.enchantment.Enchantments;
-import net.minecraft.item.BlockItem;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.MathHelper;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL14;
-
-import java.awt.*;
-import java.util.Map.Entry;
+import net.minecraft.text.Text;
+import net.minecraft.util.math.Vec3f;
 
 public class RenderUtilsLiving {
 
-    private static MinecraftClient mc = MinecraftClient.getInstance();
-    public static void drawText(String str, double x, double y, double z, double scale)
-    {
-        drawText(str, x, y, z, scale, 0.0F, 0.0F, 0.0F);
+    private static final MinecraftClient mc = MinecraftClient.getInstance();
+    private static Field shaderLightField;
+
+    /** Draws text in the world. **/
+    public static void drawText(Text text, double x, double y, double z, double scale, boolean shadow) {
+        drawText(text, x, y, z, 0, 0, scale, shadow);
     }
-    public static void drawText(String str, double x, double y, double z, double scale, float red, float green, float blue) {
-        glSetup(x, y, z);
 
-        GL11.glScaled(-0.025 * scale, -0.025 * scale, 0.025 * scale);
+    /** Draws text in the world. **/
+    public static void drawText(Text text, double x, double y, double z, double offX, double offY, double scale, boolean fill) {
+        MatrixStack matrices = matrixFrom(x, y, z);
+
+        Camera camera = mc.gameRenderer.getCamera();
+        matrices.multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(-camera.getYaw()));
+        matrices.multiply(Vec3f.POSITIVE_X.getDegreesQuaternion(camera.getPitch()));
 
-        int i = mc.textRenderer.getWidth(str) / 2;
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder bufferbuilder = tessellator.getBuffer();
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
 
-        VertexFormat.DrawMode drawMode = VertexFormat.DrawMode.QUADS;
-        bufferbuilder.begin(drawMode, VertexFormats.POSITION_COLOR);
+        matrices.translate(offX, offY, 0);
+        matrices.scale(-0.025f * (float) scale, -0.025f * (float) scale, 1);
 
-//        bufferbuilder.begin(7, VertexFormats.POSITION_COLOR);
-        float f = mc.options.getTextBackgroundOpacity(0.25F);
-        bufferbuilder.vertex(-i - 1, -1, 0.0D).color(red, green, blue, f).next();
-        bufferbuilder.vertex(-i - 1, 8, 0.0D).color(red, green, blue, f).next();
-        bufferbuilder.vertex(i + 1, 8, 0.0D).color(red, green, blue, f).next();
-        bufferbuilder.vertex(i + 1, -1, 0.0D).color(red, green, blue, f).next();
-        tessellator.draw();
-        GL11.glEnable(GL11.GL_TEXTURE_2D);
+        int halfWidth = mc.textRenderer.getWidth(text) / 2;
 
-        mc.textRenderer.draw(new MatrixStack(), str, -i, 0, 553648127);
-        mc.textRenderer.draw(new MatrixStack(), str, -i, 0, -1);
+        VertexConsumerProvider.Immediate immediate = VertexConsumerProvider.immediate(Tessellator.getInstance().getBuffer());
 
-        glCleanup();
+        if (fill) {
+            int opacity = (int) (MinecraftClient.getInstance().options.getTextBackgroundOpacity(0.25F) * 255.0F) << 24;
+            mc.textRenderer.draw(text, -halfWidth, 0f, 553648127, false, matrices.peek().getModel(), immediate, true, opacity, 0xf000f0);
+            immediate.draw();
+        } else {
+            matrices.push();
+            matrices.translate(1, 1, 0);
+            mc.textRenderer.draw(text.copy(), -halfWidth, 0f, 0x202020, false, matrices.peek().getModel(), immediate, true, 0, 0xf000f0);
+            immediate.draw();
+            matrices.pop();
+        }
+
+        mc.textRenderer.draw(text, -halfWidth, 0f, -1, false, matrices.peek().getModel(), immediate, true, 0, 0xf000f0);
+        immediate.draw();
+
+        RenderSystem.disableBlend();
     }
 
-    public static void drawItem(double x, double y, double z, double offX, double offY, double scale, ItemStack item) {
-        glSetup(x, y, z);
+    /** Draws a 2D gui items somewhere in the world. **/
+    public static void drawGuiItem(double x, double y, double z, double offX, double offY, double scale, ItemStack item) {
+        if (item.isEmpty()) {
+            return;
+        }
 
-        GL11.glScaled(0.4 * scale, 0.4 * scale, 0);
+        MatrixStack matrices = matrixFrom(x, y, z);
 
-        GL11.glTranslated(offX, offY, 0);
-        if (item.getItem() instanceof BlockItem) GL11.glRotatef(180F, 1F, 180F, 10F);
-        mc.getItemRenderer().renderItem(new ItemStack(item.getItem()), Mode.GUI, 0, 0, new MatrixStack(), mc.getBufferBuilders().getEntityVertexConsumers(),42);
-        if (item.getItem() instanceof BlockItem) GL11.glRotatef(-180F, -1F, -180F, -10F);
-        GL11.glDisable(GL11.GL_LIGHTING);
+        Camera camera = mc.gameRenderer.getCamera();
+        matrices.multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(-camera.getYaw()));
+        matrices.multiply(Vec3f.POSITIVE_X.getDegreesQuaternion(camera.getPitch()));
 
-        GL11.glScalef(-0.05F, -0.05F, 0);
+        matrices.translate(offX, offY, 0);
+        matrices.scale((float) scale, (float) scale, 0.001f);
 
-        if (item.getCount() > 0) {
-            int w = mc.textRenderer.getWidth("x" + item.getCount()) / 2;
-            mc.textRenderer.drawWithShadow(new MatrixStack(), "x" + item.getCount(), 7 - w, 5, 0xffffff);
-        }
+        matrices.multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(180f));
 
-        GL11.glScalef(0.85F, 0.85F, 0.85F);
+        //mc.getBufferBuilders().getEntityVertexConsumers().draw();
 
-        int c = 0;
-        for (Entry<Enchantment, Integer> m : EnchantmentHelper.get(item).entrySet()) {
-            int w1 = mc.textRenderer.getWidth(I18n.translate(m.getKey().getName(2).asString()).substring(0, 2) + m.getValue()) / 2;
-            mc.textRenderer.drawWithShadow(new MatrixStack(),
-                    I18n.translate(m.getKey().getName(2).asString()).substring(0, 2) + m.getValue(), -4 - w1, c * 10 - 1,
-                    m.getKey() == Enchantments.VANISHING_CURSE || m.getKey() == Enchantments.BINDING_CURSE
-                            ? 0xff5050 : 0xffb0e0);
-            c--;
-        }
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
 
-        GL11.glScalef(0.6F, 0.6F, 0.6F);
-        String dur = item.getMaxDamage() - item.getDamage() + "";
-        int color = 0x000000;
-        try {
-            color = MathHelper.hsvToRgb(((float) (item.getMaxDamage() - item.getDamage()) / item.getMaxDamage()) / 3.0F, 1.0F, 1.0F);
-        } catch (Exception e) {
-        }
-        if (item.isDamageable()) mc.textRenderer.drawWithShadow(new MatrixStack(), dur, -8 - dur.length() * 3, 15,
-                new Color(color >> 16 & 255, color >> 8 & 255, color & 255).getRGB());
+        Vec3f[] currentLight = getCurrentLight();
+        DiffuseLighting.disableGuiDepthLighting();
+
+        mc.getBufferBuilders().getEntityVertexConsumers().draw();
+
+        mc.getItemRenderer().renderItem(item, ModelTransformation.Mode.GUI, 0xF000F0,
+                OverlayTexture.DEFAULT_UV, matrices, mc.getBufferBuilders().getEntityVertexConsumers(), 0);
+
+        mc.getBufferBuilders().getEntityVertexConsumers().draw();
 
-        glCleanup();
+        RenderSystem.setShaderLights(currentLight[0], currentLight[1]);
+        RenderSystem.disableBlend();
     }
 
-    public static void glSetup(double x, double y, double z) {
-        GL11.glPushMatrix();
-        RenderUtils.offsetRender();
-        GL11.glTranslated(x, y, z);
-        GL11.glNormal3f(0.0F, 1.0F, 0.0F);
-        GL11.glRotatef(-mc.player.getYaw(), 0.0F, 1.0F, 0.0F);
-        GL11.glRotatef(mc.player.getPitch(), 1.0F, 0.0F, 0.0F);
-        //GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_DEPTH_TEST);
+    public static MatrixStack matrixFrom(double x, double y, double z) {
+        MatrixStack matrices = new MatrixStack();
 
-        GL11.glEnable(GL11.GL_BLEND);
-        GL14.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        Camera camera = mc.gameRenderer.getCamera();
+        matrices.multiply(Vec3f.POSITIVE_X.getDegreesQuaternion(camera.getPitch()));
+        matrices.multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(camera.getYaw() + 180.0F));
 
+        matrices.translate(x - camera.getPos().x, y - camera.getPos().y, z - camera.getPos().z);
+
+        return matrices;
     }
 
-    public static void glCleanup() {
-        //GL11.glEnable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_BLEND);
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        GL11.glEnable(GL11.GL_DEPTH_TEST);
-        GL11.glPopMatrix();
+    public static Vec3f[] getCurrentLight() {
+        if (shaderLightField == null) {
+            shaderLightField = FieldUtils.getField(RenderSystem.class, "shaderLightDirections", true);
+        }
+
+        try {
+            return (Vec3f[]) shaderLightField.get(null);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/Utils.java b/src/main/java/me/xmrvizzy/skyblocker/utils/Utils.java
index 538de291..7c3e44e6 100644
--- a/src/main/java/me/xmrvizzy/skyblocker/utils/Utils.java
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/Utils.java
@@ -60,7 +60,7 @@ public class Utils {
         if (sidebar.isEmpty()) return;
         if (sidebar.get(sidebar.size() - 1).equals("www.hypixel.net")) {
             if (sidebar.get(0).contains("SKYBLOCK")){
-                if(isInjected == false){
+                if(!isInjected){
                     isInjected = true;
                     ItemTooltipCallback.EVENT.register(PriceInfoTooltip::onInjectTooltip);
                 }
@@ -68,8 +68,8 @@ public class Utils {
             }
             else isSkyblock = false;
 
-            if (isSkyblock && string.contains("The Catacombs")) isDungeons = true;
-            else isDungeons = false;
+            isDungeons = isSkyblock && string.contains("The Catacombs");
+
         } else {
             isSkyblock = false;
             isDungeons = false;
diff --git a/src/main/java/me/xmrvizzy/skyblocker/utils/Vertexer.java b/src/main/java/me/xmrvizzy/skyblocker/utils/Vertexer.java
new file mode 100644
index 00000000..f9ac629e
--- /dev/null
+++ b/src/main/java/me/xmrvizzy/skyblocker/utils/Vertexer.java
@@ -0,0 +1,156 @@
+package me.xmrvizzy.skyblocker.utils;
+
+import me.xmrvizzy.skyblocker.utils.color.LineColor;
+import me.xmrvizzy.skyblocker.utils.color.QuadColor;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Matrix3f;
+import net.minecraft.util.math.Matrix4f;
+import net.minecraft.util.math.Vec3f;
+import org.apache.commons.lang3.ArrayUtils;
+
+public class Vertexer {
+
+    public static final int CULL_BACK = 0;
+    public static final int CULL_FRONT = 1;
+    public static final int CULL_NONE = 2;
+
+    public static void vertexBoxQuads(MatrixStack matrices, VertexConsumer vertexConsumer, Box box, QuadColor quadColor, Direction... excludeDirs) {
+        float x1 = (float) box.minX;
+        float y1 = (float) box.minY;
+        float z1 = (float) box.minZ;
+        float x2 = (float) box.maxX;
+        float y2 = (float) box.maxY;
+        float z2 = (float) box.maxZ;
+
+        int cullMode = excludeDirs.length == 0 ? CULL_BACK : CULL_NONE;
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.DOWN)) {
+            vertexQuad(matrices, vertexConsumer, x1, y1, z1, x2, y1, z1, x2, y1, z2, x1, y1, z2, cullMode, quadColor);
+        }
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.WEST)) {
+            vertexQuad(matrices, vertexConsumer, x1, y1, z2, x1, y2, z2, x1, y2, z1, x1, y1, z1, cullMode, quadColor);
+        }
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.EAST)) {
+            vertexQuad(matrices, vertexConsumer, x2, y1, z1, x2, y2, z1, x2, y2, z2, x2, y1, z2, cullMode, quadColor);
+        }
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.NORTH)) {
+            vertexQuad(matrices, vertexConsumer, x1, y1, z1, x1, y2, z1, x2, y2, z1, x2, y1, z1, cullMode, quadColor);
+        }
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.SOUTH)) {
+            vertexQuad(matrices, vertexConsumer, x2, y1, z2, x2, y2, z2, x1, y2, z2, x1, y1, z2, cullMode, quadColor);
+        }
+
+        if (!ArrayUtils.contains(excludeDirs, Direction.UP)) {
+            vertexQuad(matrices, vertexConsumer, x1, y2, z2, x2, y2, z2, x2, y2, z1, x1, y2, z1, cullMode, quadColor);
+        }
+    }
+
+    public static void vertexQuad(MatrixStack matrices, VertexConsumer vertexConsumer, float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, int cullMode, QuadColor quadColor) {
+        int[] color = quadColor.getAllColors();
+
+        if (cullMode != CULL_FRONT) {
+            vertexConsumer.vertex(matrices.peek().getModel(), x1, y1, z1).color(color[0], color[1], color[2], color[3]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x2, y2, z2).color(color[4], color[5], color[6], color[7]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x3, y3, z3).color(color[8], color[9], color[10], color[11]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x4, y4, z4).color(color[12], color[13], color[14], color[15]).next();
+        }
+
+        if (cullMode != CULL_BACK) {
+            vertexConsumer.vertex(matrices.peek().getModel(), x4, y4, z4).color(color[0], color[1], color[2], color[3]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x3, y3, z3).color(color[4], color[5], color[6], color[7]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x2, y2, z2).color(color[8], color[9], color[10], color[11]).next();
+            vertexConsumer.vertex(matrices.peek().getModel(), x1, y1, z1).color(color[12], color[13], color[14], color[15]).next();
+        }
+    }
+
+    public static void vertexBoxLines(MatrixStack matrices, VertexConsumer vertexConsumer, Box box, QuadColor quadColor, Direction... excludeDirs) {
+        float x1 = (float) box.minX;
+        float y1 = (float) box.minY;
+        float z1 = (float) box.minZ;
+        float x2 = (float) box.maxX;
+        float y2 = (float) box.maxY;
+        float z2 = (float) box.maxZ;
+
+        boolean exDown = ArrayUtils.contains(excludeDirs, Direction.DOWN);
+        boolean exWest = ArrayUtils.contains(excludeDirs, Direction.WEST);
+        boolean exEast = ArrayUtils.contains(excludeDirs, Direction.EAST);
+        boolean exNorth = ArrayUtils.contains(excludeDirs, Direction.NORTH);
+        boolean exSouth = ArrayUtils.contains(excludeDirs, Direction.SOUTH);
+        boolean exUp = ArrayUtils.contains(excludeDirs, Direction.UP);
+
+        int[] color = quadColor.getAllColors();
+
+        if (!exDown) {
+            vertexLine(matrices, vertexConsumer, x1, y1, z1, x2, y1, z1, LineColor.single(color[0], color[1], color[2], color[3]));
+            vertexLine(matrices, vertexConsumer, x2, y1, z1, x2, y1, z2, LineColor.single(color[4], color[5], color[6], color[7]));
+            vertexLine(matrices, vertexConsumer, x2, y1, z2, x1, y1, z2, LineColor.single(color[8], color[9], color[10], color[11]));
+            vertexLine(matrices, vertexConsumer, x1, y1, z2, x1, y1, z1, LineColor.single(color[12], color[13], color[14], color[15]));
+        }
+
+        if (!exWest) {
+            if (exDown) vertexLine(matrices, vertexConsumer, x1, y1, z1, x1, y1, z2, LineColor.single(color[0], color[1], color[2], color[3]));
+            vertexLine(matrices, vertexConsumer, x1, y1, z2, x1, y2, z2, LineColor.single(color[4], color[5], color[6], color[7]));
+            vertexLine(matrices, vertexConsumer, x1, y1, z1, x1, y2, z1, LineColor.single(color[8], color[9], color[10], color[11]));
+            if (exUp) vertexLine(matrices, vertexConsumer, x1, y2, z1, x1, y2, z2, LineColor.single(color[12], color[13], color[14], color[15]));
+        }
+
+        if (!exEast) {
+            if (exDown) vertexLine(matrices, vertexConsumer, x2, y1, z1, x2, y1, z2, LineColor.single(color[0], color[1], color[2], color[3]));
+            vertexLine(matrices, vertexConsumer, x2, y1, z2, x2, y2, z2, LineColor.single(color[4], color[5], color[6], color[7]));
+            vertexLine(matrices, vertexConsumer, x2, y1, z1, x2, y2, z1, LineColor.single(color[8], color[9], color[10], color[11]));
+            if (exUp) vertexLine(matrices, vertexConsumer, x2, y2, z1, x2, y2, z2, LineColor.single(color[12], color[13], color[14], color[15]));
+        }
+
+        if (!exNorth) {
+            if (exDown) vertexLine(matrices, vertexConsumer, x1, y1, z1, x2, y1, z1, LineColor.single(color[0], color[1], color[2], color[3]));
+            if (exEast) vertexLine(matrices, vertexConsumer, x2, y1, z1, x2, y2, z1, LineColor.single(color[4], color[5], color[6], color[7]));
+            if (exWest) vertexLine(matrices, vertexConsumer, x1, y1, z1, x1, y2, z1, LineColor.single(color[8], color[9], color[10], color[11]));
+            if (exUp) vertexLine(matrices, vertexConsumer, x1, y2, z1, x2, y2, z1, LineColor.single(color[12], color[13], color[14], color[15]));
+        }
+
+        if (!exSouth) {
+            if (exDown) vertexLine(matrices, vertexConsumer, x1, y1, z2, x2, y1, z2, LineColor.single(color[0], color[1], color[2], color[3]));
+            if (exEast) vertexLine(matrices, vertexConsumer, x2, y1, z2, x2, y2, z2, LineColor.single(color[4], color[5], color[6], color[7]));
+            if (exWest) vertexLine(matrices, vertexConsumer, x1, y1, z2, x1, y2, z2, LineColor.single(color[8], color[9], color[10], color[11]));
+            if (exUp) vertexLine(matrices, vertexConsumer, x1, y2, z2, x2, y2, z2, LineColor.single(color[12], color[13], color[14], color[15]));
+        }
+
+        if (!exUp) {
+            vertexLine(matrices, vertexConsumer, x1, y2, z1, x2, y2, z1, LineColor.single(color[0], color[1], color[2], color[3]));
+            vertexLine(matrices, vertexConsumer, x2, y2, z1, x2, y2, z2, LineColor.single(color[4], color[5], color[6], color[7]));
+            vertexLine(matrices, vertexConsumer, x2, y2, z2, x1, y2, z2, LineColor.single(color[8], color[9], color[10], color[11]));
+            vertexLine(matrices, vertexConsumer, x1, y2, z2, x1, y2, z1, LineColor.single(color[12], color[13], color[14], color[15]));