diff --git a/src/main/java/net/minecraft/client/Minecraft.java b/src/main/java/net/minecraft/client/Minecraft.java
index 3980b465d..899b5b561 100644
--- a/src/main/java/net/minecraft/client/Minecraft.java
+++ b/src/main/java/net/minecraft/client/Minecraft.java
@@ -594,7 +594,6 @@ public class Minecraft
         int height = 256;
         
         glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        tessellator.setColorOpaque_I(0xffffff);
         
         drawMojangLogoVertices((resolution.scaledWidth - width) / 2, (resolution.scaledHeight - height) / 2, 0, 0, width, height);
         
@@ -611,6 +610,7 @@ public class Minecraft
         float scaleY = 0.00390625F;
         Tessellator tessellator = Tessellator.instance;
         tessellator.startDrawingQuads();
+        tessellator.setColorOpaque_I(0xffffff);
         tessellator.addVertexWithUV(minX + 0, minY + height, 0.0D, (float)(minU + 0) * scaleX, (float)(minV + height) * scaleY);
         tessellator.addVertexWithUV(minX + width, minY + height, 0.0D, (float)(minU + width) * scaleX, (float)(minV + height) * scaleY);
         tessellator.addVertexWithUV(minX + width, minY + 0, 0.0D, (float)(minU + width) * scaleX, (float)(minV + 0) * scaleY);
diff --git a/src/main/java/net/minecraft/client/gui/GuiMainMenu.java b/src/main/java/net/minecraft/client/gui/GuiMainMenu.java
index abd878a20..5039b5b2d 100644
--- a/src/main/java/net/minecraft/client/gui/GuiMainMenu.java
+++ b/src/main/java/net/minecraft/client/gui/GuiMainMenu.java
@@ -311,7 +311,6 @@ public class GuiMainMenu extends GuiScreen
     {
         I18n i18n = I18n.getInstance();
         drawDefaultBackground();
-        Tessellator tessellator = Tessellator.instance;
         char c = '\u0112';
         int k = width / 2 - c / 2;
         byte byte0 = 30;
@@ -326,7 +325,6 @@ public class GuiMainMenu extends GuiScreen
         {
             drawLogo(partialTick);
         }
-        tessellator.setColorOpaque_I(0xffffff);
         GL11.glPushMatrix();
         GL11.glTranslatef(width / 2 + 140, 80F, 0.0F);
         GL11.glRotatef(-20F, 0.0F, 0.0F, 1.0F);
diff --git a/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java b/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
index 67b2fcc20..60ed1402d 100644
--- a/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
+++ b/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
@@ -81,7 +81,6 @@ public abstract class OptionsPages
             .withComponent(new BooleanOptionComponent(mc.gameSettings.enableVsync))
             .withComponent(new FramerateOptionComponent(mc.gameSettings.customFpsLimit))
             .withComponent(new BooleanOptionComponent(mc.gameSettings.advancedOpenGL))
-            .withComponent(new BooleanOptionComponent(mc.gameSettings.enableVbos))
         )
         .withComponent(new OptionsCategory("gui.options.page.video.category.post_processing")
             .withComponent(new FloatOptionComponent(mc.gameSettings.gamma))
diff --git a/src/main/java/net/minecraft/client/option/GameSettings.java b/src/main/java/net/minecraft/client/option/GameSettings.java
index 982b055f1..b059de517 100644
--- a/src/main/java/net/minecraft/client/option/GameSettings.java
+++ b/src/main/java/net/minecraft/client/option/GameSettings.java
@@ -8,8 +8,6 @@ import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.PrintWriter;
 
-import net.minecraft.client.option.enums.*;
-
 import org.lwjgl.opengl.Display;
 
 import com.b100.utils.ReflectUtils;
@@ -17,9 +15,15 @@ import com.b100.utils.ReflectUtils;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.discord.RichPresenceHandlerThread;
 import net.minecraft.client.gui.hud.HudComponents;
-import net.minecraft.core.enums.PlacementMode;
-import net.minecraft.client.render.tessellator.Tessellator;
+import net.minecraft.client.option.enums.Colorblindness;
+import net.minecraft.client.option.enums.Difficulty;
+import net.minecraft.client.option.enums.LightmapStyle;
+import net.minecraft.client.option.enums.MipmapType;
+import net.minecraft.client.option.enums.RenderDistance;
+import net.minecraft.client.option.enums.RenderScale;
+import net.minecraft.client.option.enums.TooltipStyle;
 import net.minecraft.client.render.window.GameWindowLWJGL2;
+import net.minecraft.core.enums.PlacementMode;
 import net.minecraft.core.lang.I18n;
 import net.minecraft.core.sound.SoundCategory;
 import net.minecraft.core.util.helper.Color;
@@ -96,7 +100,6 @@ public class GameSettings {
 	public BooleanOption showCollisionBoxes = new BooleanOption(this, "showCollisionBoxes", false);
 	public BooleanOption swapCraftingButtons = new BooleanOption(this, "swapCraftingButtons", false);
 	public BooleanOption disableJInput = new BooleanOption(this, "disableJInput", false);
-	public BooleanOption enableVbos = new BooleanOption(this, "enableVbos", false);
     public BooleanOption forceUnicodeFont = new BooleanOption(this, "forceUnicodeFont", false);
 	public EnumOption<PlacementMode> placementMode = new EnumOption<>(this, "placementMode", PlacementMode.class, PlacementMode.DEFAULT).setIsSlider(false);
 	public BooleanOption discordRichPresence = new BooleanOption(this, "discordRichPresence", false);
@@ -421,12 +424,6 @@ public class GameSettings {
 				mc.currentScreen.setWorldAndResolution(mc, mc.resolution.scaledWidth, mc.resolution.scaledHeight);
 			}
 		}
-		if(option == enableVbos){
-			Tessellator.instance.setUseVBO(enableVbos.value);
-			if (mc.renderGlobal != null){
-				mc.renderGlobal.loadRenderers();
-			}
-		}
 		if(option == lightmapStyle) {
 			if (mc.renderGlobal != null) {
 				mc.renderGlobal.loadRenderers();
diff --git a/src/main/java/net/minecraft/client/render/RenderGlobal.java b/src/main/java/net/minecraft/client/render/RenderGlobal.java
index 465418447..4c2f46948 100644
--- a/src/main/java/net/minecraft/client/render/RenderGlobal.java
+++ b/src/main/java/net/minecraft/client/render/RenderGlobal.java
@@ -1275,7 +1275,7 @@ public class RenderGlobal
             GL11.glEnable(3008 /*GL_ALPHA_TEST*/);
             tessellator.startDrawingQuads();
             tessellator.setTranslation(-x, -y, -z);
-            tessellator.disableColor();
+            tessellator.lockColor();
             BlockModel.setRenderBlocks(globalRenderBlocks);
             BlockModelDispatcher.getInstance().getDispatch(block).renderWithOverrideTexture(tessellator, hitResult.x, hitResult.y, hitResult.z, breakingAnimation[MathHelper.clamp((int)(damagePartialTime * 10F), 0, breakingAnimation.length)] );
             tessellator.draw();
diff --git a/src/main/java/net/minecraft/client/render/tessellator/Tessellator.java b/src/main/java/net/minecraft/client/render/tessellator/Tessellator.java
index 980ff3f40..2afa55e82 100644
--- a/src/main/java/net/minecraft/client/render/tessellator/Tessellator.java
+++ b/src/main/java/net/minecraft/client/render/tessellator/Tessellator.java
@@ -17,11 +17,10 @@ public abstract class Tessellator {
     public abstract void addVertex(double x, double y, double z);
     public abstract void setColorOpaque_I(int rgb);
     public abstract void setColorRGBA_I(int rgb, int a);
-    public abstract void disableColor();
+    public abstract void lockColor();
     public abstract void setNormal(float x, float y, float z);
     public abstract void setTranslation(double x, double y, double z);
     public abstract void offsetTranslation(float x, float y, float z);
     public abstract void drawRectangle(int x, int y, int width, int height);
     public abstract void drawRectangleWithUV(int x, int y, int width, int height, double u, double v, double uvWidth, double uvHeight);
-    public abstract void setUseVBO(boolean b);
 }
diff --git a/src/main/java/net/minecraft/client/render/tessellator/TessellatorStandard.java b/src/main/java/net/minecraft/client/render/tessellator/TessellatorStandard.java
index 1782b9ae1..0b8a59c59 100644
--- a/src/main/java/net/minecraft/client/render/tessellator/TessellatorStandard.java
+++ b/src/main/java/net/minecraft/client/render/tessellator/TessellatorStandard.java
@@ -1,374 +1,252 @@
 package net.minecraft.client.render.tessellator;
 
-import java.nio.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL13.*;
 
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.render.LightmapHelper;
-import net.minecraft.client.GLAllocation;
-import org.lwjgl.opengl.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
-import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
+import net.minecraft.core.util.helper.MathHelper;
 
-// Referenced classes of package net.minecraft.src:
-//            GLAllocation
+public class TessellatorStandard extends TessellatorBase {
 
-public class TessellatorStandard extends TessellatorBase
-{
+	private int drawMode;
+	private boolean drawing;
+	
+	private ByteBuffer buffer;
+	
+	private boolean hasColor;
+	private boolean hasTexture;
+	private boolean hasLightmap;
+	private boolean hasNormal;
+	
+	private int vertexCount = 0;
+	
+	private int color;
+	
+	private int lightmapCoord;
+	
+	private double textureU;
+	private double textureV;
+	
+	private byte normalX;
+	private byte normalY;
+	private byte normalZ;
+	
+	private double offsetX;
+	private double offsetY;
+	private double offsetZ;
+	
+	private boolean lockedColor = false;
+	
+	public TessellatorStandard(int bufferSize) {
+		this.buffer = ByteBuffer.allocateDirect(bufferSize).order(ByteOrder.nativeOrder());
+	}
+	
+	@Override
+	public void startDrawing(int drawMode) {
+		if(drawing) {
+			throw new IllegalStateException("Already drawing!");
+		}
+		
+		this.drawMode = drawMode;
+		this.drawing = true;
+		this.vertexCount = 0;
+		
+		this.hasColor = false;
+		this.hasTexture = false;
+		this.hasLightmap = false;
+		this.hasNormal = false;
 
-    private static boolean convertQuadsToTriangles = true;
-    private ByteBuffer byteBuffer;
-    private IntBuffer intBuffer;
-    private FloatBuffer floatBuffer;
-    private ShortBuffer shortBuffer;
-    private int rawBuffer[];
-    private int vertexCount;
-    private double textureU;
-    private double textureV;
-    private int lightmapCoord;
-    private int color;
-    private boolean hasColor;
-    private boolean hasTexture;
-    private boolean hasNormals;
-    private boolean hasLightmap;
-    private int rawBufferIndex;
-    private int addedVertices;
-    private boolean isColorDisabled;
-    private int drawMode;
-    private double xOffset;
-    private double yOffset;
-    private double zOffset;
-    private int normal;
-    private boolean isDrawing;
-    private boolean useVBO;
-    private IntBuffer vertexBuffers;
-    private int vboIndex;
-    private int vboCount = 10;
-    private int bufferSize;
-    
-	TessellatorStandard(int bufferSize)
-    {
-        this.bufferSize = bufferSize;
-        this.byteBuffer = GLAllocation.createDirectByteBuffer(bufferSize * 4);
-        this.intBuffer = byteBuffer.asIntBuffer();
-        this.floatBuffer = byteBuffer.asFloatBuffer();
-        this.shortBuffer = byteBuffer.asShortBuffer();
-        this.rawBuffer = new int[bufferSize];
-        setUseVBO(Minecraft.getMinecraft(this).gameSettings.enableVbos.value);
-    }
-    @Override
-	public void setUseVBO(boolean flag){
-        useVBO = flag && GLContext.getCapabilities().GL_ARB_vertex_buffer_object;
-        if (useVBO){
-            vertexBuffers = GLAllocation.createDirectIntBuffer(vboCount);
-            ARBVertexBufferObject.glGenBuffersARB(vertexBuffers);
-        } else {
-            GL15.glBindBuffer(GL_ARRAY_BUFFER, 0);
-        }
-    }
+		this.lockedColor = false;
+		
+		this.buffer.clear();
+	}
 
-    @Override
-	public void draw()
-    {
-    	checkIsDrawing();
-        isDrawing = false;
-        if(vertexCount > 0)
-        {
-            intBuffer.clear();
-            intBuffer.put(rawBuffer, 0, rawBufferIndex);
-            byteBuffer.position(0);
-            byteBuffer.limit(rawBufferIndex * 4);
-            if(useVBO)
-            {
-                vboIndex = (vboIndex + 1) % vboCount;
-                ARBVertexBufferObject.glBindBufferARB(34962 /*GL_ARRAY_BUFFER_ARB*/, vertexBuffers.get(vboIndex));
-                ARBVertexBufferObject.glBufferDataARB(34962 /*GL_ARRAY_BUFFER_ARB*/, byteBuffer, 35040 /*GL_STREAM_DRAW_ARB*/);
-            }
-            if(hasTexture)
-            {
-                if(useVBO)
-                {
-                    GL11.glTexCoordPointer(2, 5126 /*GL_FLOAT*/, 32, 12L);
-                } else
-                {
-                    floatBuffer.position(3);
-                    GL11.glTexCoordPointer(2, 32, floatBuffer);
-                }
-                GL11.glEnableClientState(32888 /*GL_TEXTURE_COORD_ARRAY_EXT*/);
-            }
-            if(hasLightmap)
-            {
-            	GL13.glClientActiveTexture(GL13.GL_TEXTURE1);
-            	
-            	if(useVBO) {
-            		GL11.glTexCoordPointer(2, GL11.GL_SHORT, 32, 28L);
-            	} else {
-            		shortBuffer.position(14);
-            		GL11.glTexCoordPointer(2, 32, shortBuffer);
-            	}
-            	
-            	GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
-            	GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
-            }
-            if(hasColor)
-            {
-                if(useVBO)
-                {
-                    GL11.glColorPointer(4, 5121 /*GL_UNSIGNED_BYTE*/, 32, 20L);
-                } else
-                {
-                    byteBuffer.position(20);
-                    GL11.glColorPointer(4, true, 32, byteBuffer);
-                }
-                GL11.glEnableClientState(32886 /*GL_COLOR_ARRAY_EXT*/);
-            }
-            if(hasNormals)
-            {
-                if(useVBO)
-                {
-                    GL11.glNormalPointer(5120 /*GL_BYTE*/, 32, 24L);
-                } else
-                {
-                    byteBuffer.position(24);
-                    GL11.glNormalPointer(32, byteBuffer);
-                }
-                GL11.glEnableClientState(32885 /*GL_NORMAL_ARRAY_EXT*/);
-            }
-            if(useVBO)
-            {
-                GL11.glVertexPointer(3, 5126 /*GL_FLOAT*/, 32, 0L);
-            } else
-            {
-                floatBuffer.position(0);
-                GL11.glVertexPointer(3, 32, floatBuffer);
-            }
-            GL11.glEnableClientState(32884 /*GL_VERTEX_ARRAY_EXT*/);
-            if(drawMode == 7 && convertQuadsToTriangles)
-            {
-                GL11.glDrawArrays(4, 0, vertexCount);
-            } else
-            {
-                GL11.glDrawArrays(drawMode, 0, vertexCount);
-            }
-            GL11.glDisableClientState(32884 /*GL_VERTEX_ARRAY_EXT*/);
-            if(hasTexture)
-            {
-                GL11.glDisableClientState(32888 /*GL_TEXTURE_COORD_ARRAY_EXT*/);
-            }
-            if(hasLightmap)
-            {
-            	GL13.glClientActiveTexture(GL13.GL_TEXTURE1);
-            	GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
-            	GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
-            }
-            if(hasColor)
-            {
-                GL11.glDisableClientState(32886 /*GL_COLOR_ARRAY_EXT*/);
-            }
-            if(hasNormals)
-            {
-                GL11.glDisableClientState(32885 /*GL_NORMAL_ARRAY_EXT*/);
-            }
-        }
-        reset();
-    }
+	@Override
+	public void draw() {
+		checkIsDrawing();
+		this.drawing = false;
+		
+		if(vertexCount == 0) {
+			return;
+		}
+		
+		int vertexSize = getVertexSize();
+		int offset = 0;
+		
+		buffer.flip();
+		
+		glEnableClientState(GL_VERTEX_ARRAY);
+		buffer.position(0);
+		glVertexPointer(3, GL_FLOAT, vertexSize, buffer);
+		offset += 12;
 
-    private void reset()
-    {
-        vertexCount = 0;
-        byteBuffer.clear();
-        rawBufferIndex = 0;
-        addedVertices = 0;
-    }
-    
-    @Override
-	public void startDrawing(int drawMode)
-    {
-        if(isDrawing)
-        {
-            throw new IllegalStateException("Already tesselating!");
-        }
-        else
-        {
-            isDrawing = true;
-            reset();
-            this.drawMode = drawMode;
-            hasNormals = false;
-            hasColor = false;
-            hasTexture = false;
-            hasLightmap = false;
-            isColorDisabled = false;
-        }
-    }
+		if(hasColor) {
+			glEnableClientState(GL_COLOR_ARRAY);
+			buffer.position(offset);
+			glColorPointer(4, true, vertexSize, buffer);
+			offset += 4;
+		}else {
+			glDisableClientState(GL_COLOR_ARRAY);
+		}
+		if(hasTexture) {
+			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+			buffer.position(offset);
+			glTexCoordPointer(2, GL_FLOAT, vertexSize, buffer);
+			offset += 8;
+		}else {
+			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+		}
+		if(hasLightmap) {
+			glClientActiveTexture(GL_TEXTURE1);
+			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+			buffer.position(offset);
+			glTexCoordPointer(2, GL_SHORT, vertexSize, buffer);
+			glClientActiveTexture(GL_TEXTURE0);
+			offset += 4;
+		}else {
+			glClientActiveTexture(GL_TEXTURE1);
+			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+			glClientActiveTexture(GL_TEXTURE0);
+		}
+		if(hasNormal) {
+			glEnableClientState(GL_NORMAL_ARRAY);
+			buffer.position(offset);
+			glNormalPointer(GL_BYTE, vertexSize, buffer);
+			offset += 3;
+		}else {
+			glDisableClientState(GL_NORMAL_ARRAY);
+		}
+		
+		glDrawArrays(drawMode, 0, vertexCount);
+	}
+	
+	public int getVertexSize() {
+		int vertexSize = 12;
+		if(hasColor) vertexSize += 4;
+		if(hasTexture) vertexSize += 8;
+		if(hasLightmap) vertexSize += 4;
+		if(hasNormal) vertexSize += 3;
+		return vertexSize;
+	}
 
-    @Override
-	public void setTextureUV(double u, double v)
-    {
-        hasTexture = true;
-        textureU = u;
-        textureV = v;
-    }
-    
-    @Override
-    public void setLightmapCoord(int lightmapCoord) {
-    	if(!LightmapHelper.isLightmapEnabled()) {
-    		// Enabling the texture coordinates while the lightmap is disabled shouldn't cause any issues,
-    		// but it might be a little bit slower, so we make sure that never happens!
-    		
-    		throw new IllegalStateException("Lightmap is disabled!");
-    	}
-    	hasLightmap = true;
-    	this.lightmapCoord = lightmapCoord;
-    }
-    
-    @Override
-	public void setColorRGBA(int r, int g, int b, int a)
-    {
-        if(isColorDisabled)
-        {
-            return;
-        }
-        if(r > 255)
-        {
-            r = 255;
-        }
-        if(g > 255)
-        {
-            g = 255;
-        }
-        if(b > 255)
-        {
-            b = 255;
-        }
-        if(a > 255)
-        {
-            a = 255;
-        }
-        if(r < 0)
-        {
-            r = 0;
-        }
-        if(g < 0)
-        {
-            g = 0;
-        }
-        if(b < 0)
-        {
-            b = 0;
-        }
-        if(a < 0)
-        {
-            a = 0;
-        }
-        hasColor = true;
-        if(ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN)
-        {
-            color = a << 24 | b << 16 | g << 8 | r;
-        } else
-        {
-            color = r << 24 | g << 16 | b << 8 | a;
-        }
-    }
-    
-    @Override
-	public void addVertex(double x, double y, double z)
-    {
-        addedVertices++;
-        if(drawMode == 7 && convertQuadsToTriangles && addedVertices % 4 == 0)
-        {
-            for(int i = 0; i < 2; i++)
-            {
-                int j = 8 * (3 - i);
-                if(hasTexture)
-                {
-                    rawBuffer[rawBufferIndex + 3] = rawBuffer[(rawBufferIndex - j) + 3];
-                    rawBuffer[rawBufferIndex + 4] = rawBuffer[(rawBufferIndex - j) + 4];
-                }
-                if(hasLightmap)
-                {
-                	rawBuffer[rawBufferIndex + 7] = rawBuffer[(rawBufferIndex - j) + 7];
-                }
-                if(hasColor)
-                {
-                    rawBuffer[rawBufferIndex + 5] = rawBuffer[(rawBufferIndex - j) + 5];
-                }
-                rawBuffer[rawBufferIndex + 0] = rawBuffer[(rawBufferIndex - j) + 0];
-                rawBuffer[rawBufferIndex + 1] = rawBuffer[(rawBufferIndex - j) + 1];
-                rawBuffer[rawBufferIndex + 2] = rawBuffer[(rawBufferIndex - j) + 2];
-                vertexCount++;
-                rawBufferIndex += 8;
-            }
+	@Override
+	public void addVertex(double x, double y, double z) {
+		checkIsDrawing();
 
-        }
-        if(hasTexture)
-        {
-            rawBuffer[rawBufferIndex + 3] = Float.floatToRawIntBits((float)textureU);
-            rawBuffer[rawBufferIndex + 4] = Float.floatToRawIntBits((float)textureV);
-        }
-        if(hasLightmap) {
-        	rawBuffer[rawBufferIndex + 7] = lightmapCoord;
-        }
-        if(hasColor)
-        {
-            rawBuffer[rawBufferIndex + 5] = color;
-        }
-        if(hasNormals)
-        {
-            rawBuffer[rawBufferIndex + 6] = normal;
-        }
-        rawBuffer[rawBufferIndex + 0] = Float.floatToRawIntBits((float)(x + xOffset));
-        rawBuffer[rawBufferIndex + 1] = Float.floatToRawIntBits((float)(y + yOffset));
-        rawBuffer[rawBufferIndex + 2] = Float.floatToRawIntBits((float)(z + zOffset));
-        rawBufferIndex += 8;
-        vertexCount++;
-        if(vertexCount % 4 == 0 && rawBufferIndex >= bufferSize - 32)
-        {
-            draw();
-            isDrawing = true;
-        }
-    }
-    
-    @Override
-	public void disableColor()
-    {
-        isColorDisabled = true;
-    }
+		buffer.putFloat((float) (offsetX + x));
+		buffer.putFloat((float) (offsetY + y));
+		buffer.putFloat((float) (offsetZ + z));
 
-    @Override
-	public void setNormal(float x, float y, float z)
-    {
-        if(!isDrawing)
-        {
-            System.out.println("But..");
-        }
-        hasNormals = true;
-        byte bx = (byte)(x * 127F);
-        byte by = (byte)(y * 127F);
-        byte bz = (byte)(z * 127F);
-        normal = bx | by << 8 | bz << 16;
-    }
+		if(hasColor) {
+			buffer.putInt(color);
+		}
+		if(hasTexture) {
+			buffer.putFloat((float) textureU);
+			buffer.putFloat((float) textureV);
+		}
+		if(hasLightmap) {
+			buffer.putInt(lightmapCoord);
+		}
+		if(hasNormal) {
+			buffer.put(normalX);
+			buffer.put(normalY);
+			buffer.put(normalZ);
+		}
+		
+		this.vertexCount++;
+	}
 
-    @Override
-	public void setTranslation(double x, double y, double z)
-    {
-        xOffset = x;
-        yOffset = y;
-        zOffset = z;
-    }
+	@Override
+	public void setTextureUV(double u, double v) {
+		checkIsDrawing();
+		if(!hasTexture) {
+			if(vertexCount > 0) {
+				throw new IllegalStateException("Texture is disabled!");
+			}
+			this.hasTexture = true;
+		}
+		
+		this.textureU = u;
+		this.textureV = v;
+	}
 
-    @Override
-	public void offsetTranslation(float x, float y, float z)
-    {
-        xOffset += x;
-        yOffset += y;
-        zOffset += z;
-    }
-    
-    @Override
-    public void checkIsDrawing() {
-        if(!isDrawing)
-        {
-            throw new IllegalStateException("Not tesselating!");
-        }
-    }
+	@Override
+	public void setLightmapCoord(int lightmapCoord) {
+		checkIsDrawing();
+		if(!hasLightmap) {
+			if(vertexCount > 0) {
+				throw new IllegalStateException("Lightmap is disabled!");
+			}
+			this.hasLightmap = true;
+		}
+		
+		this.lightmapCoord = lightmapCoord;
+	}
 
+	@Override
+	public void setColorRGBA(int r, int g, int b, int a) {
+		checkIsDrawing();
+		if(lockedColor) {
+			return;
+		}
+		if(!hasColor) {
+			if(vertexCount > 0) {
+				throw new IllegalStateException("Color is disabled!");
+			}
+			this.hasColor = true;
+		}
+		
+		r = MathHelper.clamp(r, 0, 255);
+		g = MathHelper.clamp(g, 0, 255);
+		b = MathHelper.clamp(b, 0, 255);
+		a = MathHelper.clamp(a, 0, 255);
+		
+		this.color = a << 24 | b << 16 | g << 8 | r;
+	}
+
+	@Override
+	public void setNormal(float x, float y, float z) {
+		checkIsDrawing();
+		if(!hasNormal) {
+			if(vertexCount > 0) {
+				throw new IllegalStateException("Texture is disabled!");
+			}
+			this.hasNormal = true;
+		}
+		
+		this.normalX = (byte) (x * 127.0f);
+		this.normalY = (byte) (y * 127.0f);
+		this.normalZ = (byte) (z * 127.0f);
+	}
+
+	@Override
+	public void lockColor() {
+		checkIsDrawing();
+		
+		this.lockedColor = true;
+	}
+
+	@Override
+	public void setTranslation(double x, double y, double z) {
+		this.offsetX = x;
+		this.offsetY = y;
+		this.offsetZ = z;
+	}
+
+	@Override
+	public void offsetTranslation(float x, float y, float z) {
+		this.offsetX += x;
+		this.offsetY += y;
+		this.offsetZ += z;
+	}
+	
+	@Override
+	public void checkIsDrawing() {
+		if(!drawing) {
+			throw new IllegalStateException("Not drawing!");
+		}
+	}
+	
 }
diff --git a/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderOverworld.java b/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderOverworld.java
index a80c83e70..dd89f99fd 100644
--- a/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderOverworld.java
+++ b/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderOverworld.java
@@ -394,7 +394,8 @@ public final class BiomeProviderOverworld
                 new BiomeRange(0.95, 1.0, 0.85, 1.0, 0.0, 1.0, 0.0, 1.0)
         );
         brm.lock();
-
-        brm.generateDebugImage(true);
+        
+//		Stop turning this on it crashes servers
+//        brm.generateDebugImage(true);
     }
 }
