src/com/apocalyptech/minecraft/xray/Chunk.java

/**
 * Copyright (c) 2010-2011, Vincent Vollers and Christopher J. Kucera
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Minecraft X-Ray team nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL VINCENT VOLLERS OR CJ KUCERA BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package com.apocalyptech.minecraft.xray;

import java.lang.Math;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;

import org.lwjgl.opengl.GL11;

import com.apocalyptech.minecraft.xray.dtf.ShortArrayTag;
import com.apocalyptech.minecraft.xray.dtf.ByteArrayTag;
import com.apocalyptech.minecraft.xray.dtf.CompoundTag;
import com.apocalyptech.minecraft.xray.dtf.StringTag;
import com.apocalyptech.minecraft.xray.dtf.ListTag;
import com.apocalyptech.minecraft.xray.dtf.IntTag;
import com.apocalyptech.minecraft.xray.dtf.Tag;

import static com.apocalyptech.minecraft.xray.MinecraftConstants.*;

/**
 * Chunk functions, including the meat of our rendering stuffs
 *
 * TODO: There are a lot of functions that do very similar things in here, it would be
 * good to consolidate some of those.  I don't know why it took me so long to come
 * up with the current implementation of renderVertical and renderHorizontal - I suspect
 * that much of the rendering code would be improved by moving to those if possible.
 */
public class Chunk {
	private HashMap<Integer, Integer> displayListNums;
	private HashMap<Integer, Integer> nonstandardListNums;
	private HashMap<Integer, Integer> glassListNums;
	private HashMap<Integer, Integer> selectedDisplayListNums;
	public int x;
	public int z;
	public HashMap<Integer, Boolean> isDirty;
	public HashMap<Integer, Boolean> isSelectedDirty;
	public boolean isOnMinimap;
	private CompoundTag chunkData;
	private ShortArrayTag blockData;
	private ByteArrayTag mapData;
	private ArrayList<PaintingEntity> paintings;
	
	private MinecraftLevel level;

	public HashMap<Integer, Boolean> usedTextureSheets;

	private final float fence_postsize = .125f;
	private final float fence_postsize_h = fence_postsize/2f;
	private final float fence_slat_height = .1875f;
	private final float fence_top_slat_offset = .375f;
	private final float fence_slat_start_offset = -.125f;

	private static enum RENDER_PASS {
		SOLIDS,
		NONSTANDARD,
		GLASS,
		SELECTED
	}
	
	public Chunk(MinecraftLevel level, Tag data) {
		
		this.level = level;
		this.chunkData = (CompoundTag) data;
		this.isOnMinimap = false;

		CompoundTag levelTag = (CompoundTag) chunkData.value.get(0); // first tag
		IntTag xPosTag = (IntTag) levelTag.getTagWithName("xPos");
		IntTag zPosTag = (IntTag) levelTag.getTagWithName("zPos");
		
		paintings = new ArrayList<PaintingEntity>();
		ListTag entities = (ListTag)levelTag.getTagWithName("Entities");
		StringTag entity_id;
		CompoundTag ct;
		for (Tag t : entities.value)
		{
			ct = (CompoundTag)t;
			entity_id = (StringTag) ct.getTagWithName("id");
			if (entity_id.value.equalsIgnoreCase("painting"))
			{
				paintings.add(new PaintingEntity(ct));
			}
		}
		
		this.x = xPosTag.value;
		this.z = zPosTag.value;
		
		blockData = (ShortArrayTag) levelTag.getTagWithName("Blocks");
		mapData = (ByteArrayTag) levelTag.getTagWithName("Data");

		// Compute which texture sheets are in-use by this chunk
		// Much of this is copied from our main render loop, way down below
		this.usedTextureSheets = new HashMap<Integer, Boolean>();
		for(int x=0; x<16; x++) {
			int xOff = (x * 128 * 16);
			for(int z=0; z<16; z++) {
				int zOff = (z * 128);
				int blockOffset = zOff + xOff-1;
				for(int y=0; y<128; y++) {
					blockOffset++;
					int t = blockData.value[blockOffset];
					if(t < 1) {
						continue;
					}
					BlockType block = blockArray[t];
					if (block == null)
					{
						block = BLOCK_UNKNOWN;
					}
					this.usedTextureSheets.put(block.getTexSheet(), true);
				}
			}
		}

		// And create all our necessary GL Lists (and other structures)
		displayListNums = new HashMap<Integer, Integer>();
		nonstandardListNums = new HashMap<Integer, Integer>();
		glassListNums = new HashMap<Integer, Integer>();
		selectedDisplayListNums = new HashMap<Integer, Integer>();
		this.isDirty = new HashMap<Integer, Boolean>();
		this.isSelectedDirty = new HashMap<Integer, Boolean>();
		for (int sheet : this.usedTextureSheets.keySet())
		{
			displayListNums.put(sheet, GL11.glGenLists(1));
			selectedDisplayListNums.put(sheet, GL11.glGenLists(1));
			glassListNums.put(sheet, GL11.glGenLists(1));
			nonstandardListNums.put(sheet, GL11.glGenLists(1));
			this.isDirty.put(sheet, true);
			this.isSelectedDirty.put(sheet, true);
		}
		
		//System.out.println(data);
		//System.exit(0);
	}

	/**
	 * Returns whether or not this chunk contains blocks which use the specified sheet
	 */
	public boolean usesSheet(int sheet)
	{
		return this.usedTextureSheets.containsKey(sheet);
	}

	/**
	 * Marks a our lists as dirty
	 */
	public void setDirty()
	{
		for (Map.Entry<Integer, Boolean> entry : this.isDirty.entrySet())
		{
			entry.setValue(true);
		}
	}

	/**
	 * Marks a our selected lists as dirty
	 */
	public void setSelectedDirty()
	{
		for (Map.Entry<Integer, Boolean> entry : this.isSelectedDirty.entrySet())
		{
			entry.setValue(true);
		}
	}
	
	public CompoundTag getChunkData() {
		return this.chunkData;
	}
	
	public ShortArrayTag getMapData() {
		return this.blockData;
	}

	/**
	 * Gets the Block ID of the block immediately to the north.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private short getAdjNorthBlockId(int x, int y, int z, int blockOffset)
	{
		if (x > 0)
		{
			return blockData.value[blockOffset-BLOCKSPERCOLUMN];
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x-1, this.z);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getBlock(15, y, z);
			}
		}
	}

	/**
	 * Gets the data value of the block immediately to the north.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private byte getAdjNorthBlockData(int x, int y, int z)
	{
		if (x > 0)
		{
			return getData(x-1, y, z);
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x-1, this.z);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getData(15, y, z);
			}
		}
	}

	/**
	 * Gets the Block ID of the block immediately to the south.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private short getAdjSouthBlockId(int x, int y, int z, int blockOffset)
	{
		if (x < 15)
		{
			return blockData.value[blockOffset+BLOCKSPERCOLUMN];
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x+1, this.z);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getBlock(0, y, z);
			}
		}
	}

	/**
	 * Gets the data value of the block immediately to the south.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private byte getAdjSouthBlockData(int x, int y, int z)
	{
		if (x < 15)
		{
			return getData(x+1, y, z);
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x+1, this.z);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getData(0, y, z);
			}
		}
	}

	/**
	 * Gets the Block ID of the block immediately to the east.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private short getAdjEastBlockId(int x, int y, int z, int blockOffset)
	{
		if (z > 0)
		{
			return blockData.value[blockOffset-BLOCKSPERROW];
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x, this.z-1);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getBlock(x, y, 15);
			}
		}
	}

	/**
	 * Gets the data value of the block immediately to the east.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private byte getAdjEastBlockData(int x, int y, int z)
	{
		if (z > 0)
		{
			return getData(x, y, z-1);
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x, this.z-1);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getData(x, y, 15);
			}
		}
	}

	/**
	 * Gets the Block ID of the block immediately to the west.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private short getAdjWestBlockId(int x, int y, int z, int blockOffset)
	{
		if (z < 15)
		{
			return blockData.value[blockOffset+BLOCKSPERROW];
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x, this.z+1);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getBlock(x, y, 0);
			}
		}
	}

	/**
	 * Gets the data value of the block immediately to the west.  This might
	 * load in the adjacent chunk, if needed.  Will return -1 if that adjacent
	 * chunk can't be found.
	 */
	private byte getAdjWestBlockData(int x, int y, int z)
	{
		if (z < 15)
		{
			return getData(x, y, z+1);
		}
		else
		{
			Chunk otherChunk = level.getChunk(this.x, this.z+1);
			if (otherChunk == null)
			{
				return -1;
			}
			else
			{
				return otherChunk.getData(x, y, 0);
			}
		}
	}
	
	/**
	 * Render something which is a North/South face.
	 */
	public void renderNorthSouth(int t, float x, float y, float z) {
		this.renderNorthSouth(t, x, y, z, 0.5f, 0.5f);
	}
	
	/**
	 * Render something which is a North/South face.
	 * 
	 * @param t Texture to render
	 * @param x
	 * @param y
	 * @param z
	 * @param yHeightOffset How tall this block is.  0.5f is the usual, specify 0 for half-height
	 * @param xzScale How large the rest of the block is.  0.5f is full-size, 0.1 would be tiny.
	 */
	public void renderNorthSouth(int t, float x, float y, float z, float yHeightOffset, float xzScale) {
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t], precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x-xzScale, y+yHeightOffset, z+xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x-xzScale, y+yHeightOffset, z-xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t],precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x-xzScale, y-xzScale, z+xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x-xzScale, y-xzScale, z-xzScale);
		GL11.glEnd();
	}
	
	/**
	 * Renders a floor tile which is also rotated
	 * 
	 * @param t
	 * @param x
	 * @param y
	 * @param z
	 * @param turns The number of clockwise 90-degree turns to rotate the texture
	 */
	public void renderTopDownRotate(int t, float x, float y, float z, int turns)
	{
		float scale = 0.5f;
		float tx = precalcSpriteSheetToTextureX[t];
		float ty = precalcSpriteSheetToTextureY[t];
		float x1, y1;
		float x2, y2;
		float x3, y3;
		float x4, y4;
		
		switch (turns)
		{
			case 0:
				x1 = tx;       y1 = ty;
				x2 = tx+TEX16; y2 = ty;
				x3 = tx;       y3 = ty+TEX32;
				x4 = tx+TEX16; y4 = ty+TEX32;
				break;
			case 1:
				x1 = tx+TEX16; y1 = ty;
				x2 = tx+TEX16; y2 = ty+TEX32;
				x3 = tx;       y3 = ty;
				x4 = tx;       y4 = ty+TEX32;
				break;
			case 2:
				x1 = tx+TEX16; y1 = ty+TEX32;
				x2 = tx;       y2 = ty+TEX32;
				x3 = tx+TEX16; y3 = ty;
				x4 = tx;       y4 = ty;
				break;
			case 3:
			default:
				x1 = tx;       y1 = ty+TEX32;
				x2 = tx;       y2 = ty;
				x3 = tx+TEX16; y3 = ty+TEX32;
				x4 = tx+TEX16; y4 = ty;
				break;
		}
		
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(x1, y1);
			GL11.glVertex3f(x-scale, y-scale, z+scale);
	
			GL11.glTexCoord2f(x2, y2);
			GL11.glVertex3f(x-scale, y-scale, z-scale);
	
			GL11.glTexCoord2f(x3, y3);
			GL11.glVertex3f(x+scale, y-scale, z+scale);
	
			GL11.glTexCoord2f(x4, y4);
			GL11.glVertex3f(x+scale, y-scale, z-scale);
		GL11.glEnd();
		
	}
	
	/**
	 * Render the top or bottom of a block, depending on how we're looking at it.
	 */
	public void renderTopDown(int t, float x, float y, float z) {
		this.renderTopDown(t, x, y, z, 0.5f);
	}
	
	/**
	 * Render the top or bottom of a block, depending on how we're looking at it.
	 * 
	 * @param t The texture ID to draw
	 * @param x
	 * @param y
	 * @param z
	 * @param scale ".5" is a full-sized block, ".1" would be tiny.
	 */
	public void renderTopDown(int t, float x, float y, float z, float scale) {
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t], precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x-scale, y-scale, z+scale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x-scale, y-scale, z-scale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t], precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x+scale, y-scale, z+scale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x+scale, y-scale, z-scale);
		GL11.glEnd();
	}
	

	/**
	 * Renders something which is a West/East face.
	 */
	public void renderWestEast(int t, float x, float y, float z) {
		this.renderWestEast(t, x, y, z, 0.5f, 0.5f);
	}
	
	/**
	 * Renders something which is a West/East face.
	 * 
	 * @param t Texture to draw
	 * @param x
	 * @param y
	 * @param z
	 * @param yHeightOffset How tall this block is.  0.5f is the usual, specify 0 for half-height
	 * @param xzScale How large the rest of the block is.  0.5f is full-size, 0.1 would be tiny.
	 */
	public void renderWestEast(int t, float x, float y, float z, float yHeightOffset, float xzScale) {
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t], precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x-xzScale, y+yHeightOffset, z-xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]);
			GL11.glVertex3f(x+xzScale, y+yHeightOffset, z-xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t], precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x-xzScale, y-xzScale, z-xzScale);
	
			GL11.glTexCoord2f(precalcSpriteSheetToTextureX[t]+TEX16, precalcSpriteSheetToTextureY[t]+TEX32);
			GL11.glVertex3f(x+xzScale, y-xzScale, z-xzScale);
		GL11.glEnd();
	}


	/**
	 * Renders a vertical texture with a full square texture.
	 */
	public void renderVertical(int t, float x1, float z1, float x2, float z2, float y, float height) {
		renderVertical(t, x1, z1, x2, z2, y, height, 16, 16, 0, 0);
	}

	/**
	 * Renders a somewhat-arbitrary vertical rectangle.  Pass in (x, z) pairs for the endpoints,
	 * and information about the height.  The texture variables given are in terms of 1/16ths of
	 * the texture square, which means that for the default Minecraft 16x16 texture, they're in
	 * pixels.
	 * 
	 * @param t Texture to draw
	 * @param x1
	 * @param z1
	 * @param x2
	 * @param z2
	 * @param y	The lower part of the rectangle
	 * @param height Height of the rectangle.
	 */
	public void renderVertical(int t, float x1, float z1, float x2, float z2, float y, float height, int tex_width, int tex_height, int tex_start_x, int tex_start_y) {

		float bx = precalcSpriteSheetToTextureX[t]+(TEX256*tex_start_x);
		float by = precalcSpriteSheetToTextureY[t]+(TEX512*tex_start_y);

		float tdx = TEX256*tex_width;
		float tdy = TEX512*tex_height;

		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x1, y+height, z1);
	
			GL11.glTexCoord2f(bx+tdx, by);
			GL11.glVertex3f(x2, y+height, z2);
	
			GL11.glTexCoord2f(bx, by+tdy);
			GL11.glVertex3f(x1, y, z1);
	
			GL11.glTexCoord2f(bx+tdx, by+tdy);
			GL11.glVertex3f(x2, y, z2);
		GL11.glEnd();
	}
	
	/**
	 * Renders a nonstandard vertical rectangle (nonstandard referring primarily to
	 * the texture size (ie: when we're not pulling a single element out of a 16x16
	 * grid).  This differs from renderVertical also in that we specify two full
	 * (x, y, z) coordinates for the bounds, instead of passing in y and a height.
	 * Texture coordinates are passed in as the usual float from 0 to 1.
	 * 
	 * @param tx X index within the texture
	 * @param ty Y index within the texture
	 * @param tdx Width of texture
	 * @param tdy Height of texture
	 * @param x1
	 * @param y1
	 * @param z1
	 * @param x2
	 * @param y2
	 * @param z2
	 */
	public void renderNonstandardVertical(float tx, float ty, float tdx, float tdy, float x1, float y1, float z1, float x2, float y2, float z2)
	{
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(tx, ty);
			GL11.glVertex3f(x1, y1, z1);
			
			GL11.glTexCoord2f(tx+tdx, ty);
			GL11.glVertex3f(x2, y1, z2);
			
			GL11.glTexCoord2f(tx, ty+tdy);
			GL11.glVertex3f(x1, y2, z1);
			
			GL11.glTexCoord2f(tx+tdx, ty+tdy);
			GL11.glVertex3f(x2, y2, z2);
		GL11.glEnd();
	}
	
	/**
	 * Renders a nonstandard vertical rectangle (nonstandard referring primarily to
	 * the texture size (ie: when we're not pulling a single element out of a 16x16
	 * grid).  This differs from renderVertical also in that we specify two full
	 * (x, y, z) coordinates for the bounds, instead of passing in y and a height.
	 * Texture coordinates are passed in as the usual float from 0 to 1.
	 *
	 * Additionally, this method will rotate the texture while drawing; I needed this
	 * for Pistons, specifically - will probably come in handy elsewhere too.
	 * 
	 * @param tx X index within the texture
	 * @param ty Y index within the texture
	 * @param tdx Width of texture
	 * @param tdy Height of texture
	 * @param x1
	 * @param y1
	 * @param z1
	 * @param x2
	 * @param y2
	 * @param z2
	 */
	public void renderNonstandardVerticalTexRotate(float tx, float ty, float tdx, float tdy, float x1, float y1, float z1, float x2, float y2, float z2)
	{
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(tx+tdx, ty);
			GL11.glVertex3f(x1, y1, z1);
			
			GL11.glTexCoord2f(tx+tdx, ty+tdy);
			GL11.glVertex3f(x2, y1, z2);
			
			GL11.glTexCoord2f(tx, ty);
			GL11.glVertex3f(x1, y2, z1);
			
			GL11.glTexCoord2f(tx, ty+tdy);
			GL11.glVertex3f(x2, y2, z2);
		GL11.glEnd();
	}

	/**
	 * Renders a "default" horizontal rectangle, using a full square for the texture.
	 */
	public void renderHorizontal(int t, float x1, float z1, float x2, float z2, float y) {
		renderHorizontal(t, x1, z1, x2, z2, y, 16, 16, 0, 0, false);
	}
	
	/**
	 * Renders an arbitrary horizontal rectangle (will be orthogonal).  The texture parameters
	 * are specified in terms of 1/16ths of the texture (which equates to one pixel, when using
	 * the default 16x16 Minecraft texture.
	 *
	 * @param t
	 * @param x1
	 * @param z1
	 * @param x2
	 * @param z2
	 * @param y
	 */
	public void renderHorizontal(int t, float x1, float z1, float x2, float z2, float y, int tex_width, int tex_height, int tex_start_x, int tex_start_y, boolean flip_tex) {

		float bx = precalcSpriteSheetToTextureX[t]+(TEX256*tex_start_x);
		float by = precalcSpriteSheetToTextureY[t]+(TEX512*tex_start_y);

		float tdx = TEX256*tex_width;
		float tdy = TEX512*tex_height;

		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			
			if (flip_tex)
			{
				GL11.glTexCoord2f(bx, by);
				GL11.glVertex3f(x1, y, z2);
		
				GL11.glTexCoord2f(bx+tdx, by);
				GL11.glVertex3f(x2, y, z2);
		
				GL11.glTexCoord2f(bx, by+tdy);
				GL11.glVertex3f(x1, y, z1);
		
				GL11.glTexCoord2f(bx+tdx, by+tdy);
				GL11.glVertex3f(x2, y, z1);
			}
			else
			{
				GL11.glTexCoord2f(bx, by);
				GL11.glVertex3f(x1, y, z1);
		
				GL11.glTexCoord2f(bx+tdx, by);
				GL11.glVertex3f(x1, y, z2);
		
				GL11.glTexCoord2f(bx, by+tdy);
				GL11.glVertex3f(x2, y, z1);
		
				GL11.glTexCoord2f(bx+tdx, by+tdy);
				GL11.glVertex3f(x2, y, z2);
			}
		GL11.glEnd();
	}
	
	/**
	 * Render a surface on a horizontal plane; pass in all four verticies.  This can result,
	 * obviously, in non-rectangular and non-orthogonal shapes.
	 * 
	 * @param t
	 * @param x1
	 * @param z1
	 * @param x2
	 * @param z2
	 * @param x3
	 * @param z3
	 * @param x4
	 * @param z4
	 * @param y
	 */
	public void renderHorizontalAskew(int t, float x1, float z1, float x2, float z2, float x3, float z3, float x4, float z4, float y) {

		float bx = precalcSpriteSheetToTextureX[t];
		float by = precalcSpriteSheetToTextureY[t];

		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x1, y, z1);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x2, y, z2);
	
			GL11.glTexCoord2f(bx, by+TEX32);
			GL11.glVertex3f(x3, y, z3);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x4, y, z4);
		GL11.glEnd();
	}
	
	/**
	 * Renders a nonstandard horizontal rectangle (nonstandard referring primarily to
	 * the texture size (ie: when we're not pulling a single element out of a 16x16
	 * grid).
	 * 
	 * @param tx X index within the texture
	 * @param ty Y index within the texture
	 * @param tdx Width of texture
	 * @param tdy Height of texture
	 * @param x1
	 * @param z1
	 * @param x2
	 * @param z2
	 * @param y
	 */
	public void renderNonstandardHorizontal(float tx, float ty, float tdx, float tdy, float x1, float z1, float x2, float z2, float y) {
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(tx, ty);
			GL11.glVertex3f(x1, y, z1);
	
			GL11.glTexCoord2f(tx+tdx, ty);
			GL11.glVertex3f(x1, y, z2);
	
			GL11.glTexCoord2f(tx, ty+tdy);
			GL11.glVertex3f(x2, y, z1);
	
			GL11.glTexCoord2f(tx+tdx, ty+tdy);
			GL11.glVertex3f(x2, y, z2);
		GL11.glEnd();
	}

	/**
	 * Renders a nonstandard horizontal rectangle (nonstandard referring primarily to
	 * the texture size (ie: when we're not pulling a single element out of a 16x16
	 * grid).
	 *
	 * Additionally, this method will rotate the texture while drawing; I needed this
	 * for Pistons, specifically - will probably come in handy elsewhere too.
	 * 
	 * @param tx X index within the texture
	 * @param ty Y index within the texture
	 * @param tdx Width of texture
	 * @param tdy Height of texture
	 * @param x1
	 * @param z1
	 * @param x2
	 * @param z2
	 * @param y
	 */
	public void renderNonstandardHorizontalTexRotate(float tx, float ty, float tdx, float tdy, float x1, float z1, float x2, float z2, float y) {
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(tx+tdx, ty);
			GL11.glVertex3f(x1, y, z1);
	
			GL11.glTexCoord2f(tx+tdx, ty+tdy);
			GL11.glVertex3f(x1, y, z2);
	
			GL11.glTexCoord2f(tx, ty);
			GL11.glVertex3f(x2, y, z1);
	
			GL11.glTexCoord2f(tx, ty+tdy);
			GL11.glVertex3f(x2, y, z2);
		GL11.glEnd();
	}

	/**
	 * Given a whole mess of coordinates, draws an arbitrary rectangle
	 * 
	 * @param t
	 * @param x1
	 * @param y1
	 * @param z1
	 * @param x2
	 * @param y2
	 * @param z2
	 * @param x3
	 * @param y3
	 * @param z3
	 * @param x4
	 * @param y4
	 * @param z4
	 */
	public void renderArbitraryRect(int t,
			float x1, float y1, float z1,
			float x2, float y2, float z2,
			float x3, float y3, float z3,
			float x4, float y4, float z4)
	{
		float tx = precalcSpriteSheetToTextureX[t];
		float ty = precalcSpriteSheetToTextureY[t];

		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(tx, ty);
			GL11.glVertex3f(x1, y1, z1);
	
			GL11.glTexCoord2f(tx+TEX16, ty);
			GL11.glVertex3f(x2, y2, z2);
	
			GL11.glTexCoord2f(tx, ty+TEX32);
			GL11.glVertex3f(x3, y3, z3);
	
			GL11.glTexCoord2f(tx+TEX16, ty+TEX32);
			GL11.glVertex3f(x4, y4, z4);
		GL11.glEnd();
		
	}
	
	/**
	 * Renders the side of a stair piece that runs East/West.  Verticies are in the following order:
	 * <pre>
	 *         6---5
	 *         |   |
	 *     2---4   |
	 *     |       |
	 *     1-------3
	 * </pre>
	 * 
	 * Note that the function is "WestEast" which corresponds to the stair direction;
	 * this will actually draw the face on the north or south sides.
	 * 
	 * @param t
	 * @param x
	 * @param y
	 * @param z
	 */
	public void renderStairSideWestEast(int t, float x, float y, float z, boolean swapZ) {
		
		float bx = precalcSpriteSheetToTextureX[t];
		float by = precalcSpriteSheetToTextureY[t];
		
		float zoff=0.5f;
		if (swapZ)
		{
			zoff = -0.5f;
		}
		
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
		
			GL11.glTexCoord2f(bx, by+TEX32);
			GL11.glVertex3f(x-0.5f, y-0.5f, z+zoff);
	
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x-0.5f, y, z+zoff);
			
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x-0.5f, y-0.5f, z-zoff);
	
			GL11.glTexCoord2f(bx+TEX32, by+TEX64);
			GL11.glVertex3f(x-0.5f, y, z);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x-0.5f, y+0.5f, z-zoff);
			
			GL11.glTexCoord2f(bx+TEX32, by);
			GL11.glVertex3f(x-0.5f, y+0.5f, z);

		GL11.glEnd();
	}	

	/**
	 * Renders the stair surface, for a stair running West/East
	 * 
	 * @param t Texture to draw
	 * @param x
	 * @param y
	 * @param z
	 * @param swapX
	 */
	public void renderStairSurfaceWestEast(int t, float x, float y, float z, boolean swapZ) {
		
		float bx = precalcSpriteSheetToTextureX[t];
		float by = precalcSpriteSheetToTextureY[t];
		
		float zoff = 0.5f;
		if (swapZ)
		{
			zoff = -0.5f;
		}
		
		// Lower Step surface
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x+0.5f, y, z+zoff);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x-0.5f, y, z+zoff);
	
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x+0.5f, y, z);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x-0.5f, y, z);
		GL11.glEnd();

		// Lower Step Side
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x+0.5f, y, z+zoff);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x-0.5f, y, z+zoff);
	
			GL11.glTexCoord2f(bx,by+TEX32);
			GL11.glVertex3f(x+0.5f, y-0.5f, z+zoff);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x-0.5f, y-0.5f, z+zoff);
		GL11.glEnd();

		// Higher Step surface
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x+0.5f, y+0.5f, z);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x-0.5f, y+0.5f, z);
	
			GL11.glTexCoord2f(bx, by+TEX32);
			GL11.glVertex3f(x+0.5f, y+0.5f, z-zoff);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x-0.5f, y+0.5f, z-zoff);
		GL11.glEnd();

		// Higher Step Side
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x+0.5f, y+0.5f, z);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x-0.5f, y+0.5f, z);
	
			GL11.glTexCoord2f(bx,by+TEX64);
			GL11.glVertex3f(x+0.5f, y, z);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x-0.5f, y, z);
		GL11.glEnd();
	}
	
	/**
	 * Renders the side of a stair piece that runs North/South.  Verticies are in the following order:
	 * <pre>
	 *         6---5
	 *         |   |
	 *     2---4   |
	 *     |       |
	 *     1-------3
	 * </pre>
	 * 
	 * Note that the function is "NorthSouth" which corresponds to the stair direction;
	 * this will actually draw the face on the east or west sides.
	 * 
	 * @param t
	 * @param x
	 * @param y
	 * @param z
	 */
	public void renderStairSideNorthSouth(int t, float x, float y, float z, boolean swapX) {
		
		float bx = precalcSpriteSheetToTextureX[t];
		float by = precalcSpriteSheetToTextureY[t];
		
		float xoff=0.5f;
		if (swapX)
		{
			xoff = -0.5f;
		}
		
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
		
			GL11.glTexCoord2f(bx, by+TEX32);
			GL11.glVertex3f(x+xoff, y-0.5f, z-0.5f);
	
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x+xoff, y, z-0.5f);
			
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x-xoff, y-0.5f, z-0.5f);
	
			GL11.glTexCoord2f(bx+TEX32, by+TEX64);
			GL11.glVertex3f(x, y, z-0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x-xoff, y+0.5f, z-0.5f);
			
			GL11.glTexCoord2f(bx+TEX32, by);
			GL11.glVertex3f(x, y+0.5f, z-0.5f);

		GL11.glEnd();
	}	

	/**
	 * Renders the stair surface, for a stair running North/South
	 * 
	 * @param t Texture to draw
	 * @param x
	 * @param y
	 * @param z
	 * @param swapX
	 */
	public void renderStairSurfaceNorthSouth(int t, float x, float y, float z, boolean swapX) {
		
		float bx = precalcSpriteSheetToTextureX[t];
		float by = precalcSpriteSheetToTextureY[t];
		
		float xoff = 0.5f;
		if (swapX)
		{
			xoff = -0.5f;
		}
		
		// Lower Step surface
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x+xoff, y, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x+xoff, y, z-0.5f);
	
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x, y, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x, y, z-0.5f);
		GL11.glEnd();

		// Lower Step Side
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x+xoff, y, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x+xoff, y, z-0.5f);
	
			GL11.glTexCoord2f(bx,by+TEX32);
			GL11.glVertex3f(x+xoff, y-0.5f, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x+xoff, y-0.5f, z-0.5f);
		GL11.glEnd();

		// Higher Step surface
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by+TEX64);
			GL11.glVertex3f(x, y+0.5f, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x, y+0.5f, z-0.5f);
	
			GL11.glTexCoord2f(bx, by+TEX32);
			GL11.glVertex3f(x-xoff, y+0.5f, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX32);
			GL11.glVertex3f(x-xoff, y+0.5f, z-0.5f);
		GL11.glEnd();


		// Higher Step Side
		GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
			GL11.glTexCoord2f(bx, by);
			GL11.glVertex3f(x, y+0.5f, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by);
			GL11.glVertex3f(x, y+0.5f, z-0.5f);
	
			GL11.glTexCoord2f(bx,by+TEX64);
			GL11.glVertex3f(x, y, z+0.5f);
	
			GL11.glTexCoord2f(bx+TEX16, by+TEX64);
			GL11.glVertex3f(x, y, z-0.5f);
		GL11.glEnd();
	}
	
	/**
	 * Gets the block ID at the specified coordinate in the chunk.  This is
	 * only really used in the getAdj*BlockId() methods.
	 */
	public short getBlock(int x, int y, int z) {
		return blockData.value[y + (z * 128) + (x * 128 * 16)];
	}

	/**
	 * Gets the block data at the specified coordinates.
	 */
	public byte getData(int x, int y, int z) {
		int offset = y + (z * 128) + (x * 128 * 16);
		int halfOffset = offset / 2;
		if(offset % 2 == 0) {
			return (byte) (mapData.value[halfOffset] & 0xF);
		} else {
			// We shouldn't have to &0xF here, but if we don't the value
			// returned could be negative, even though that would be silly.
			return (byte) ((mapData.value[halfOffset] >> 4) & 0xF);
		}
	}
	
	/**
	 * Renders a torch, making an attempt to render properly given the wall face it's
	 * attached to, etc.  We take in textureId because we support redstone torches as
	 * well.
	 *
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderTorch(int textureId, int xxx, int yyy, int zzz) {
		 byte data = getData(xxx, yyy, zzz);
		 data &= 0xF;
		 switch (data) {
			 case 1:
				 renderRectDecoration(textureId, xxx, yyy, zzz, -30, 0f, 1f, -.6f, 0f);
				 return;
			 case 2:
				 renderRectDecoration(textureId, xxx, yyy, zzz, 30, 0f, 1f, .6f, 0f);
				 return;
			 case 3:
				 renderRectDecoration(textureId, xxx, yyy, zzz, 30, 1f, 0f, 0f, -.6f);
				 return;
			 case 4:
				 renderRectDecoration(textureId, xxx, yyy, zzz, -30, 1f, 0f, 0f, .6f);
				 return;
			 default:
				 renderRectDecoration(textureId, xxx, yyy, zzz);
				 return;
		 }
	}
	
	/**
	 * Renders a lever; copied and modified from renderTorch for the most part.
	 * TODO: Looks no better than the torches; should put the cobble base on at the least.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderLever(int textureId, int xxx, int yyy, int zzz)
	{
		byte data = getData(xxx, yyy, zzz);
		boolean thrown = false;
		if ((data & 0x8) == 0x8)
		{
			thrown = true;
		}
		data &= 7;
		//System.out.println("Data: " + data);
		 
		// First draw the cobblestoney box
		int cobble_tex = BLOCK_COBBLESTONE.tex_idx;
		float box_height = .15f;
		float box_length = .2f;
		float box_width = .15f;
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		switch (data) {
			case 1:
				renderVertical(cobble_tex, x-.5f, z+box_width, x-.5f+box_height, z+box_width, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x-.5f, z-box_width, x-.5f+box_height, z-box_width, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x-.5f+box_height, z+box_width, x-.5f+box_height, z-box_width, y-box_length, box_length*2f);
				renderHorizontal(cobble_tex, x-.5f, z-box_width, x-.5f+box_height, z+box_width, y-box_length);
				renderHorizontal(cobble_tex, x-.5f, z-box_width, x-.5f+box_height, z+box_width, y+box_length);
				break;
			case 2:
				renderVertical(cobble_tex, x+.5f, z+box_width, x+.5f-box_height, z+box_width, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x+.5f, z-box_width, x+.5f-box_height, z-box_width, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x+.5f-box_height, z+box_width, x+.5f-box_height, z-box_width, y-box_length, box_length*2f);
				renderHorizontal(cobble_tex, x+.5f, z-box_width, x+.5f-box_height, z+box_width, y-box_length);
				renderHorizontal(cobble_tex, x+.5f, z-box_width, x+.5f-box_height, z+box_width, y+box_length);
				break;
			case 3:
				renderVertical(cobble_tex, x-box_width, z-.5f, x-box_width, z-.5f+box_height, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x+box_width, z-.5f, x+box_width, z-.5f+box_height, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x-box_width, z-.5f+box_height, x+box_width, z-.5f+box_height, y-box_length, box_length*2f);
				renderHorizontal(cobble_tex, x-box_width, z-.5f, x+box_width, z-.5f+box_height, y-box_length);
				renderHorizontal(cobble_tex, x-box_width, z-.5f, x+box_width, z-.5f+box_height, y+box_length);
				break;
			case 4:
				renderVertical(cobble_tex, x-box_width, z+.5f, x-box_width, z+.5f-box_height, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x+box_width, z+.5f, x+box_width, z+.5f-box_height, y-box_length, box_length*2f);
				renderVertical(cobble_tex, x-box_width, z+.5f-box_height, x+box_width, z+.5f-box_height, y-box_length, box_length*2f);
				renderHorizontal(cobble_tex, x-box_width, z+.5f, x+box_width, z+.5f-box_height, y-box_length);
				renderHorizontal(cobble_tex, x-box_width, z+.5f, x+box_width, z+.5f-box_height, y+box_length);
				break;
			case 5:
				renderVertical(cobble_tex, x-box_width, z+box_length, x-box_width, z-box_length, y-.5f, box_height);
				renderVertical(cobble_tex, x+box_width, z+box_length, x+box_width, z-box_length, y-.5f, box_height);
				renderVertical(cobble_tex, x-box_width, z+box_length, x+box_width, z+box_length, y-.5f, box_height);
				renderVertical(cobble_tex, x+box_width, z-box_length, x-box_width, z-box_length, y-.5f, box_height);
				renderHorizontal(cobble_tex, x-box_width, z-box_length, x+box_width, z+box_length, y-.5f+box_height);
				break;
			case 6:
			default:
				renderVertical(cobble_tex, x-box_length, z+box_width, x-box_length, z-box_width, y-.5f, box_height);
				renderVertical(cobble_tex, x+box_length, z+box_width, x+box_length, z-box_width, y-.5f, box_height);
				renderVertical(cobble_tex, x-box_length, z+box_width, x+box_length, z+box_width, y-.5f, box_height);
				renderVertical(cobble_tex, x+box_length, z-box_width, x-box_length, z-box_width, y-.5f, box_height);
				renderHorizontal(cobble_tex, x-box_length, z-box_width, x+box_length, z+box_width, y-.5f+box_height);
				break;
		}

		// Now draw the lever itself
		if (thrown)
		{
			switch (data) {
				case 1:
					renderRectDecoration(textureId, xxx, yyy+1, zzz, -135, 0f, 1f, .6f, 0f);
					break;
				case 2:
					renderRectDecoration(textureId, xxx, yyy+1, zzz, 135, 0f, 1f, -.6f, 0f);
					break;
				case 3:
					renderRectDecoration(textureId, xxx, yyy+1, zzz, 135, 1f, 0f, 0f, .6f);
					break;
				case 4:
					renderRectDecoration(textureId, xxx, yyy+1, zzz, -135, 1f, 0f, 0f, -.6f);
					break;
				case 5:
					renderRectDecoration(textureId, xxx, yyy, zzz, -45, 1f, 0f, 0f, 0f);
					break;
				case 6:
					renderRectDecoration(textureId, xxx, yyy, zzz, 45, 0f, 1f, 0f, 0f);
					break;
			}
		}
		else
		{
			switch (data) {
				case 1:
					renderRectDecoration(textureId, xxx, yyy, zzz, -45, 0f, 1f, -.6f, 0f);
					break;
				case 2:
					renderRectDecoration(textureId, xxx, yyy, zzz, 45, 0f, 1f, .6f, 0f);
					break;
				case 3:
					renderRectDecoration(textureId, xxx, yyy, zzz, 45, 1f, 0f, 0f, -.6f);
					break;
				case 4:
					renderRectDecoration(textureId, xxx, yyy, zzz, -45, 1f, 0f, 0f, .6f);
					break;
				case 5:
					renderRectDecoration(textureId, xxx, yyy, zzz, 45, 1f, 0f, 0f, 0f);
					break;
				case 6:
					renderRectDecoration(textureId, xxx, yyy, zzz, -45, 0f, 1f, 0f, 0f);
					break;
			}
		}
	}

	/**
	 * Renders a decoration which is supposed to be a "cross" in a single block.  There's
	 * some code duplication from renderRectDecoration in here, but not too much, hopefully.
	 * This will require an entry in XRay.decorationStats for the given textureId.
	 */
	public void renderCrossDecoration(int textureId, int xxx, int yyy, int zzz)
	{
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy - 0.5f;

		// We do the "% 256" here because our texture ID might be in the "highlighted"
		// range, for Explored highlighting.
		TextureDecorationStats stats = XRay.decorationStats.get(textureId % 256);
		if (stats == null)
		{
			return;
		}
		float tex_begin_x = precalcSpriteSheetToTextureX[textureId] + stats.getTexLeft();
		float tex_begin_y = precalcSpriteSheetToTextureY[textureId] + stats.getTexTop();
		float tex_width = stats.getTexWidth();
		float tex_height = stats.getTexHeight();

		float width = stats.getWidth();
		float width_h = width/2f;
		float height = stats.getHeight();
		float top_tex_height;

		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x-width_h, y+height, z-width_h,
				x+width_h, y, z+width_h);
		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x+width_h, y+height, z-width_h,
				x-width_h, y, z+width_h);
	}

	/**
	 * Renders an rectangular decoration which is just standing straight up.  This will require
	 * an entry in XRay.decorationStats for the given textureId.
	 *
	 * Currently only used for torches and levers, actually.
	 */
	public void renderRectDecoration(int textureId, int xxx, int yyy, int zzz)
	{
		renderRectDecoration(textureId, xxx, yyy, zzz, 0, 0f, 0f, 0f, 0f);
	}

	/**
	 * Renders a rectangular decoration.  This will require an entry in XRay.decorationStats for
	 * the given textureId.  Optionally pass in some parameters for rotation, currently used
	 * for torches and levers.
	 *
	 * @param textureId Texture to draw
	 * @param xxx Chunk X
	 * @param yyy Chunk Y
	 * @param zzz Chunk Z
	 * @param rotate_degrees Degrees to rotate, use zero for no rotation
	 * @param rotate_x Use 1.0f to rotate in the X direction (passed to glRotatef)
	 * @param rotate_z Use 1.0f to rotate in the X direction (passed to glRotatef)
	 * @param x_off X offset, so it's not just in the center
	 * @param z_off Z offset, so it's not just in the center
	 */
	public void renderRectDecoration(int textureId, int xxx, int yyy, int zzz,
			int rotate_degrees, float rotate_x, float rotate_z, float x_off, float z_off)
	{
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy - 0.5f;

		boolean do_rotate = false;
		float tx=0, ty=0, tz=0;
		if (rotate_degrees != 0)
		{
			tx = x;
			ty = y;
			tz = z;
			x = x_off;
			y = 0;
			z = z_off;
			do_rotate = true;
		}

		float my_x = xxx + this.x*16;
		float my_z = zzz + this.z*16;
		float my_y = yyy - 0.5f;
		// We do the "% 256" here because our texture ID might be in the "highlighted"
		// range, for Explored highlighting.
		TextureDecorationStats stats = XRay.decorationStats.get(textureId % 256);
		if (stats == null)
		{
			return;
		}

		float tex_begin_x = precalcSpriteSheetToTextureX[textureId] + stats.getTexLeft();
		float tex_begin_y = precalcSpriteSheetToTextureY[textureId] + stats.getTexTop();
		float tex_width = stats.getTexWidth();
		float tex_height = stats.getTexHeight();

		float width = stats.getWidth();
		float width_h = width/2f;
		float height = stats.getHeight();
		float top_tex_height;
		if (height > width)
		{
			top_tex_height = tex_width/2f;
		}
		else
		{
			top_tex_height = tex_height;
		}

		// Math is for suckers; let's let the video hardware take care of rotation
		// Relatedly, is this how I should be drawing *everything?*  Draw relative
		// to the origin for the actual verticies, and then translate?
		if (do_rotate)
		{
			GL11.glPushMatrix();
			GL11.glTranslatef(tx, ty, tz);
			GL11.glRotatef((float)rotate_degrees, rotate_x, 0f, rotate_z);
		}
		
		// First draw the borders
		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x-width_h, y+height, z-width_h,
				x+width_h, y, z-width_h);
		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x-width_h, y+height, z+width_h,
				x+width_h, y, z+width_h);
		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x+width_h, y+height, z-width_h,
				x+width_h, y, z+width_h);
		renderNonstandardVertical(tex_begin_x, tex_begin_y, tex_width, tex_height,
				x-width_h, y+height, z+width_h,
				x-width_h, y, z-width_h);

		// Now the top
		renderNonstandardHorizontal(tex_begin_x, tex_begin_y, tex_width, top_tex_height,
				x-width_h, z-width_h,
				x+width_h, z+width_h,
				y+height);

		if (do_rotate)
		{
			GL11.glPopMatrix();
		}
	}
	
	/**
	 * Renders a "grid" decoration (in the manner of crops and netherwart)
	 * 
	 * @param textureId Texture
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderGridDecoration(int textureId, int xxx, int yyy, int zzz)
	{
		 float x = xxx + this.x*16;
		 float z = zzz + this.z*16;
		 float y = yyy;

		// We do the "% 256" here because our texture ID might be in the "highlighted"
		// range, for Explored highlighting.
		TextureDecorationStats stats = XRay.decorationStats.get(textureId % 256);
		if (stats == null)
		{
			return;
		}

		 float tex_x = precalcSpriteSheetToTextureX[textureId] + stats.getTexLeft();
		 float tex_y = precalcSpriteSheetToTextureY[textureId] + stats.getTexTop();
		 float tex_dx = stats.getTexWidth();
		 float tex_dy = stats.getTexHeight();

		 float width_h = stats.getWidth()/2;
		 float side_offset = .25f;
		 float bottom = y -.5f;
		 float top = bottom + stats.getHeight();

		 // now each side
		 renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				 x-width_h, top, z+side_offset,
				 x+width_h, bottom, z+side_offset);

		 renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				 x-width_h, top, z-side_offset,
				 x+width_h, bottom, z-side_offset);

		 renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				 x+side_offset, top, z-width_h,
				 x+side_offset, bottom, z+width_h);

		 renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				 x-side_offset, top, z-width_h,
				 x-side_offset, bottom, z+width_h);
	}
	
	/**
	 * Renders crops.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderCrops(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		 
		 // Adjust for crop size
		 byte data = getData(xxx, yyy, zzz);
		 if (data > 7)
		 {
			 data = 7;
		 }
		 int tex_offset = (7-data);
		 if (tex_offset > 0)
		 {
			 textureId = block.texture_extra_map.get("smaller_" + tex_offset);
		 }
		 renderGridDecoration(textureId, xxx, yyy, zzz);
	}
	
	/**
	 * Renders netherwart.
	 *
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderNetherWart(int textureId, int xxx, int yyy, int zzz, BlockType block) {

		 // Adjust for size
		 byte data = getData(xxx, yyy, zzz);
		 //System.out.println("Netherwart data: " + data);
		 if (data > 3)
		 {
			 data = 3;
		 }
		 int tex_offset = 2-((data+1)/2);
		 if (tex_offset > 0)
		 {
			 textureId = block.texture_extra_map.get("smaller_" + tex_offset);
		 }
		 renderGridDecoration(textureId, xxx, yyy, zzz);
	}
    
	/**
	 * Renders a ladder, given its attached-side data.  We still take in textureId just so
	 * that everything's still defined in MinecraftConstants
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderLadder(int textureId, int xxx, int yyy, int zzz) {
		 float x = xxx + this.x*16;
		 float z = zzz + this.z*16;
		 float y = yyy;
		 
		 byte data = getData(xxx, yyy, zzz);
		 switch(data)
		 {
		 	case 2:
		 		// East
		 		this.renderWestEast(textureId, x, y, z+1.0f-TEX64);
		 		break;
		 	case 3:
		 		// West
		 		this.renderWestEast(textureId, x, y, z+TEX64);
		 		break;
		 	case 4:
		 		// North
		 		this.renderNorthSouth(textureId, x+1.0f-TEX64, y, z);
		 		break;
		 	case 5:
	 		default:
	 			// South
				this.renderNorthSouth(textureId, x+TEX64, y, z);
	 			break;
		 }
	}
    
	/**
	 * Renders a vine, given its attached-side data.  Pretty much identical
	 * to renderLadder, except that there's different data values.  Alas!
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderVine(int textureId, int xxx, int yyy, int zzz, int blockOffset) {
		 float x = xxx + this.x*16;
		 float z = zzz + this.z*16;
		 float y = yyy;
		 
		 byte data = getData(xxx, yyy, zzz);
		 boolean rendered = false;
		 if ((data & 1) == 1)
		 {
			// West
			this.renderWestEast(textureId, x, y, z+1.0f-TEX64);
			rendered = true;
		 }
		 if ((data & 2) == 2)
		 {
			// North
			this.renderNorthSouth(textureId, x+TEX64, y, z);
			rendered = true;
		 }
		 if ((data & 4) == 4)
		 {
			// East
			this.renderWestEast(textureId, x, y, z+TEX64);
			rendered = true;
		 }
		 if ((data & 8) == 8)
		 {
			// South
			this.renderNorthSouth(textureId, x+1.0f-TEX64, y, z);
			rendered = true;
		 }
		 if (data == 0 || (rendered && yyy < 127 && isSolid(blockData.value[blockOffset+1])))
		 {
			// Top
			this.renderHorizontal(textureId, x-.5f, z-.5f, x+.5f, z+.5f, y+.45f);
		 }
	}

	/**
	 * This is actually used for rendering "decoration" type things which are on
	 * the floor (eg: minecart tracks, redstone wires, etc)
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderFloor(int textureId, int xxx, int yyy, int zzz) {
		 float x = xxx + this.x*16;
		 float z = zzz + this.z*16;
		 float y = yyy;
		 
		this.renderTopDown(textureId, x, y+TEX64, z);
	}

	/**
	 * Minecart tracks
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderMinecartTracks(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		 
		byte data = getData(xxx, yyy, zzz);
		if (data > 0x5)
		{
			textureId = block.texture_extra_map.get("curve");
		}
 
		switch (data)
		{
			case 0x0:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 1);
				break;
			case 0x1:
				this.renderTopDown(textureId, x, y+TEX64, z);
				break;
			case 0x2:
				this.renderArbitraryRect(textureId,
						x-0.5f, y-0.5f, z+0.5f,
						x-0.5f, y-0.5f, z-0.5f,
						x+0.5f, y+0.5f, z+0.5f,
						x+0.5f, y+0.5f, z-0.5f
						);
				break;
			case 0x3:
				this.renderArbitraryRect(textureId,
						x-0.5f, y+0.5f, z+0.5f,
						x-0.5f, y+0.5f, z-0.5f,
						x+0.5f, y-0.5f, z+0.5f,
						x+0.5f, y-0.5f, z-0.5f
						);
				break;
			case 0x4:
				this.renderArbitraryRect(textureId,
						x-0.5f, y+0.5f, z-0.5f,
						x+0.5f, y+0.5f, z-0.5f,
						x-0.5f, y-0.5f, z+0.5f,
						x+0.5f, y-0.5f, z+0.5f
						);
				break;
			case 0x5:
				this.renderArbitraryRect(textureId,
						x-0.5f, y-0.5f, z-0.5f,
						x+0.5f, y-0.5f, z-0.5f,
						x-0.5f, y+0.5f, z+0.5f,
						x+0.5f, y+0.5f, z+0.5f
						);
				break;
			case 0x6:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 3);
				break;
			case 0x7:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 2);
				break;
			case 0x8:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 1);
				break;
			case 0x9:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 0);
				break;
			default:
				// Just do the usual for now
				this.renderTopDown(textureId, x, y+TEX64, z);
				break;
		}
	}

	/**
	 * "Simple" rails, which don't have corners.  This actually isn't as
	 * simple as it should be, since we have a special-case for powered rails.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderSimpleRail(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		 
		byte data = getData(xxx, yyy, zzz);
		byte powered = data;
		powered >>= 3;
		if (powered > 0)
		{
			// This is just for powered rails, to light them up properly
			textureId = block.texture_extra_map.get("powered");
		}
		data &= 7;
 
		switch (data)
		{
			case 0x0:
				this.renderTopDownRotate(textureId, x, y+TEX64, z, 1);
				break;
			case 0x1:
				this.renderTopDown(textureId, x, y+TEX64, z);
				break;
			case 0x2:
				this.renderArbitraryRect(textureId,
						x-0.5f, y-0.5f, z+0.5f,
						x-0.5f, y-0.5f, z-0.5f,
						x+0.5f, y+0.5f, z+0.5f,
						x+0.5f, y+0.5f, z-0.5f
						);
				break;
			case 0x3:
				this.renderArbitraryRect(textureId,
						x-0.5f, y+0.5f, z+0.5f,
						x-0.5f, y+0.5f, z-0.5f,
						x+0.5f, y-0.5f, z+0.5f,
						x+0.5f, y-0.5f, z-0.5f
						);
				break;
			case 0x4:
				this.renderArbitraryRect(textureId,
						x-0.5f, y+0.5f, z-0.5f,
						x+0.5f, y+0.5f, z-0.5f,
						x-0.5f, y-0.5f, z+0.5f,
						x+0.5f, y-0.5f, z+0.5f
						);
				break;
			case 0x5:
				this.renderArbitraryRect(textureId,
						x-0.5f, y-0.5f, z-0.5f,
						x+0.5f, y-0.5f, z-0.5f,
						x-0.5f, y+0.5f, z+0.5f,
						x+0.5f, y+0.5f, z+0.5f
						);
				break;
			default:
				// Just do the usual for now
				this.renderTopDown(textureId, x, y+TEX64, z);
				break;
		}
	}
	
	/**
	 * Renders a pressure plate.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderPlate(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		float radius = 0.4f;
		
		// The plate itself
		this.renderHorizontal(textureId, x+radius, z+radius, x-radius, z-radius, y-0.45f);
		
		// Sides
		this.renderVertical(textureId, x+radius, z+radius, x+radius, z-radius, y-0.5f, 0.05f);
		this.renderVertical(textureId, x-radius, z+radius, x-radius, z-radius, y-0.5f, 0.05f);
		this.renderVertical(textureId, x+radius, z+radius, x-radius, z+radius, y-0.5f, 0.05f);
		this.renderVertical(textureId, x+radius, z-radius, x-radius, z-radius, y-0.5f, 0.05f);
	}

	/**
	 * Renders a thin slice of something on the ground (used for snow currently).  Practically
	 * the same as renderPlate actually, just wider and a bit taller
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderThinslice(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		float radius = 0.48f;
		
		// The top face
		this.renderHorizontal(textureId, x+radius, z+radius, x-radius, z-radius, y-0.38f);
		
		// Sides
		this.renderVertical(textureId, x+radius, z+radius, x+radius, z-radius, y-0.48f, 0.1f);
		this.renderVertical(textureId, x-radius, z+radius, x-radius, z-radius, y-0.48f, 0.1f);
		this.renderVertical(textureId, x+radius, z+radius, x-radius, z+radius, y-0.48f, 0.1f);
		this.renderVertical(textureId, x+radius, z-radius, x-radius, z-radius, y-0.48f, 0.1f);
	}

	/**
	 * Renders a bed block.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderBed(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		float side_part = 0.49f;
		float side_full = 0.5f;
		float bed_height = 0.5625f;
		float horiz_off = bed_height-0.5f;
		float bed_tex_height = TEX256/2f*9f;
		boolean head = true;

		byte data = getData(xxx, yyy, zzz);
		data &= 0xF;
		if ((data & 0x8) == 0)
		{
			textureId = block.texture_extra_map.get("foot_top");
			head = false;
		}
		data &= 0x3;

		// Use GL to rotate these properly
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);

		// We're drawing the bed with the head facing East (direction 2)
		if (data == 0)
		{
			// Pointing West
			GL11.glRotatef(180f, 0f, 1f, 0f);
		}
		else if (data == 1)
		{
			// Pointing North
			GL11.glRotatef(90f, 0f, 1f, 0f);
		}
		else if (data == 3)
		{
			// Pointing South
			GL11.glRotatef(-90f, 0f, 1f, 0f);
		}

		float end_tex_x, end_tex_y;
		float first_z, second_z, end_z;
		float side_tex_x, side_tex_y;
		if (head)
		{
			end_tex_x = precalcSpriteSheetToTextureX[block.texture_extra_map.get("head")];
			end_tex_y = precalcSpriteSheetToTextureY[block.texture_extra_map.get("head")+16]-bed_tex_height;
			side_tex_x = precalcSpriteSheetToTextureX[block.texture_extra_map.get("head_side")];
			side_tex_y = precalcSpriteSheetToTextureY[block.texture_extra_map.get("head_side")+16]-bed_tex_height;
			first_z = side_full;
			second_z = -side_part;
			end_z = -side_part;
		}
		else
		{
			end_tex_x = precalcSpriteSheetToTextureX[block.texture_extra_map.get("foot")];
			end_tex_y = precalcSpriteSheetToTextureY[block.texture_extra_map.get("foot")+16]-bed_tex_height;
			side_tex_x = precalcSpriteSheetToTextureX[block.texture_extra_map.get("foot_side")];
			side_tex_y = precalcSpriteSheetToTextureY[block.texture_extra_map.get("foot_side")+16]-bed_tex_height;
			first_z = side_part;
			second_z = -side_full;
			end_z = side_part;
		}

		// Top face
		this.renderHorizontal(textureId, side_part, first_z, -side_part, second_z, horiz_off);

		// Side faces
		this.renderNonstandardVertical(side_tex_x, side_tex_y, TEX16, bed_tex_height, side_part, bed_height-side_full, first_z, side_part, -side_full, second_z);
		this.renderNonstandardVertical(side_tex_x, side_tex_y, TEX16, bed_tex_height, -side_part, bed_height-side_full, first_z, -side_part, -side_full, second_z);

		// end face (either the very foot or the very head of the bed)
		this.renderNonstandardVertical(end_tex_x, end_tex_y, TEX16, bed_tex_height, side_part, bed_height-side_full, end_z, -side_part, -side_full, end_z);

		// Pop the matrix
		GL11.glPopMatrix();
	}
	
	/**
	 * Renders a door
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderDoor(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		
		byte data = getData(xxx, yyy, zzz);
		if ((data & 0x8) == 0x0)
		{
			textureId = block.texture_extra_map.get("bottom");
		}
		boolean swung = false;
		if ((data & 0x4) == 0x4)
		{
			swung = true;
		}
		int dir = (data & 0x3);

		// TODO: need to fix texture orientation
		if ((dir == 3 && swung) || (dir == 0 && !swung))
		{
			// North			
			this.renderNorthSouth(textureId, x, y, z);
		}
		else if ((dir == 0 && swung) || (dir == 1 && !swung))
		{
			// East
			this.renderWestEast(textureId, x, y, z);
		}
		else if ((dir == 1 && swung) || (dir == 2 && !swung))
		{
			// South
			this.renderNorthSouth(textureId, x+1, y, z);
		}
		else
		{
			// West
			this.renderWestEast(textureId, x, y, z+1);
		}
		
	}
	
	/**
	 * Renders a trapdoor
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderTrapdoor(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		float twidth = .1f;
		//float twidth_h = twidth/2f;
		float toff = .02f;
		
		byte data = getData(xxx, yyy, zzz);
		boolean swung = false;
		if ((data & 0x4) == 0x4)
		{
			swung = true;
		}
		int dir = (data & 0x3);

		float tex_x = precalcSpriteSheetToTextureX[textureId];
		float tex_y = precalcSpriteSheetToTextureY[textureId];
		float tex_dx = TEX16;
		float tex_dy = TEX32 * twidth;

		// Use GL to rotate these properly
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);
		if (swung)
		{
			if (dir == 0)
			{
				// West
				GL11.glRotatef(-90f, 1f, 0f, 0f);
			}
			else if (dir == 1)
			{
				// East
				GL11.glRotatef(90f, 1f, 0f, 0f);
			}
			else if (dir == 2)
			{
				// South
				GL11.glRotatef(90f, 0f, 0f, 1f);
			}
			else
			{
				// North
				GL11.glRotatef(-90f, 0f, 0f, 1f);
			}
		}
		
		// First the faces
		//this.renderHorizontal(textureId, .5f-toff, .5f-toff, -.5f+toff, -.5f+toff, -.5f+toff);
		this.renderHorizontal(textureId, .5f-toff, .5f-toff, -.5f+toff, -.5f+toff, -.5f+toff+twidth);

		// Now the sides
		this.renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				.5f-toff, -.5f+toff,         .5f-toff,
				-.5f+toff, -.5f+toff+twidth, .5f-toff);
		this.renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				.5f-toff, -.5f+toff,        .5f-toff,
				.5f-toff, -.5f+toff+twidth, -.5f+toff);
		this.renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				-.5f+toff, -.5f+toff,        -.5f+toff,
				-.5f+toff, -.5f+toff+twidth, .5f-toff);
		this.renderNonstandardVertical(tex_x, tex_y, tex_dx, tex_dy,
				-.5f+toff, -.5f+toff,       -.5f+toff,
				.5f-toff, -.5f+toff+twidth, -.5f+toff);

		GL11.glPopMatrix();
	}
	
	/**
	 * Renders stair graphics
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderStairs(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		
		byte data = getData(xxx, yyy, zzz);
		boolean swap = false;
		if (data == 0 || data == 2)
		{
			swap = true;
		}

		if (data == 0 || data == 1)
		{
			// 0 is ascending-south, 1 is ascending-north
			
			// Sides
			this.renderStairSideNorthSouth(textureId, x, y, z+.05f, swap);
			this.renderStairSideNorthSouth(textureId, x, y, z+.95f, swap);
			
			// Back
			if (swap)
			{
				this.renderNorthSouth(textureId, x+0.94f, y, z, 0.5f, 0.45f);
			}
			else
			{
				this.renderNorthSouth(textureId, x+0.06f, y, z, 0.5f, 0.45f);
			}
			
			// Bottom
			this.renderTopDown(textureId, x, y, z, 0.45f);
			
			// Stair Surface
			this.renderStairSurfaceNorthSouth(textureId, x, y, z, swap);
		}
		else
		{
			// 2 is ascending-west, 3 is ascending-east
			
			// Sides
			this.renderStairSideWestEast(textureId, x+.05f, y, z, swap);
			this.renderStairSideWestEast(textureId, x+.95f, y, z, swap);
			
			// Back
			if (swap)
			{
				this.renderWestEast(textureId, x, y, z+0.94f, 0.5f, 0.45f);
			}
			else
			{
				this.renderWestEast(textureId, x, y, z+0.06f, 0.5f, 0.45f);
			}
			
			// Bottom
			this.renderTopDown(textureId, x, y, z, 0.45f);
			
			// Stair Surface
			this.renderStairSurfaceWestEast(textureId, x, y, z, swap);		
		}
		
	}
	
	/**
	 * Renders a signpost.
	 * TODO: show the actual message
	 * TODO: should be solid instead of just one plane
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderSignpost(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		
		float signBottom = 0f;
		float signHeight = .6f;
		float postRadius = .05f;
		float face_spacing = 3; // in degrees
		
		// First a signpost
		this.renderVertical(textureId, x-postRadius, z-postRadius, x+postRadius, z-postRadius, y-0.5f, 0.5f+signBottom);
		this.renderVertical(textureId, x-postRadius, z+postRadius, x+postRadius, z+postRadius, y-0.5f, 0.5f+signBottom);
		this.renderVertical(textureId, x+postRadius, z-postRadius, x+postRadius, z+postRadius, y-0.5f, 0.5f+signBottom);
		this.renderVertical(textureId, x-postRadius, z+postRadius, x-postRadius, z-postRadius, y-0.5f, 0.5f+signBottom);
		
		// Signpost top
		this.renderHorizontal(textureId, x-postRadius, z-postRadius, x+postRadius, z+postRadius, y+signBottom);
		
		// Now we continue to draw the sign itself.
		byte data = getData(xxx, yyy, zzz);
		data &= 0xF;
		// data: 0 is West, increasing numbers add 22.5 degrees (so 4 is North, 8 south, etc)
		// Because we're not actually drawing the message (yet), as far as we're concerned
		// West is the same as East, etc.
		float angle = (data % 8) * 22.5f;
		float radius = 0.5f;

		angle -= face_spacing;
		// First x/z
		float x1a = x + radius * (float)Math.cos(Math.toRadians(angle));
		float z1a = z + radius * (float)Math.sin(Math.toRadians(angle));
		angle += face_spacing*2;
		float x1b = x + radius * (float)Math.cos(Math.toRadians(angle));
		float z1b = z + radius * (float)Math.sin(Math.toRadians(angle));
		
		// Now the other side
		angle += 180;
		float x2a = x + radius * (float)Math.cos(Math.toRadians(angle));
		float z2a = z + radius * (float)Math.sin(Math.toRadians(angle));
		angle -= face_spacing*2;
		float x2b = x + radius * (float)Math.cos(Math.toRadians(angle));
		float z2b = z + radius * (float)Math.sin(Math.toRadians(angle));
		
		// Faces
		this.renderVertical(textureId, x1a, z1a, x2a, z2a, y+signBottom, signHeight);
		this.renderVertical(textureId, x1b, z1b, x2b, z2b, y+signBottom, signHeight);
		
		// Sides
		this.renderVertical(textureId, x1a, z1a, x1b, z1b, y+signBottom, signHeight);
		this.renderVertical(textureId, x2a, z2a, x2b, z2b, y+signBottom, signHeight);
		
		// Top/Bottom
		this.renderHorizontalAskew(textureId, x1a, z1a, x1b, z1b, x2a, z2a, x2b, z2b, y+signBottom);
		this.renderHorizontalAskew(textureId, x1a, z1a, x1b, z1b, x2a, z2a, x2b, z2b, y+signBottom+signHeight);
	}
	
	/**
	 * Renders a wall sign.  This is virtually identical to renderLadder, except that
	 * we draw a smaller box, basically.
	 * TODO: Would be kind of neat to actually draw the message, too.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderWallSign(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		float faceX1, faceX2;
		float faceZ1, faceZ2;
 		float back_dX, back_dZ;
 		float sign_length = 0.4f;
		
		byte data = getData(xxx, yyy, zzz);
		switch(data)
		{
		 	case 2:
		 		// East
	 			faceX1 = x-sign_length;
	 			faceX2 = x+sign_length;
	 			faceZ1 = z+0.45f;
	 			faceZ2 = z+0.45f;
	 			back_dX = 0f;
	 			back_dZ = 0.05f;
		 		break;
		 	case 3:
		 		// West
	 			faceX1 = x-sign_length;
	 			faceX2 = x+sign_length;
	 			faceZ1 = z-0.45f;
	 			faceZ2 = z-0.45f;
	 			back_dX = 0f;
	 			back_dZ = -0.05f;
		 		break;
		 	case 4:
		 		// North
	 			faceX1 = x+0.45f;
	 			faceX2 = x+0.45f;
	 			faceZ1 = z-sign_length;
	 			faceZ2 = z+sign_length;
	 			back_dX = 0.05f;
	 			back_dZ = 0f;
		 		break;
		 	case 5:
	 		default:
	 			// South
	 			faceX1 = x-0.45f;
	 			faceX2 = x-0.45f;
	 			faceZ1 = z-sign_length;
	 			faceZ2 = z+sign_length;
	 			back_dX = -0.05f;
	 			back_dZ = 0f;
	 			break;
		}
		
		// Face
		this.renderVertical(textureId, faceX1, faceZ1, faceX2, faceZ2, y-0.2f, 0.5f);
		
		// Sides
		this.renderVertical(textureId, faceX1, faceZ1, faceX1+back_dX, faceZ1+back_dZ, y-0.2f, 0.5f);
		this.renderVertical(textureId, faceX2, faceZ2, faceX2+back_dX, faceZ2+back_dZ, y-0.2f, 0.5f);
		
		// Top/Bottom
		this.renderHorizontal(textureId, faceX1, faceZ1, faceX2+back_dX, faceZ2+back_dZ, y-0.2f);
		this.renderHorizontal(textureId, faceX1, faceZ1, faceX2+back_dX, faceZ2+back_dZ, y+0.3f);
	}
	
	/**
	 * Renders a fence.  Note that as of 1.9-pre, the two kinds of fences (regular and nether)
	 * won't link up with each other, but either will attach to a nearby Fence Gate, if they can.
	 *
	 * TODO: Sort out the proper texture offsets + orientations, or at least do it consistently
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 * @param blockOffset Should be passed in from our main draw loop so we don't have to recalculate
	 */
	public void renderFence(int textureId, int xxx, int yyy, int zzz, int blockOffset, int blockId) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		float slat_start = y+fence_slat_start_offset;
		
		// First the fencepost
		this.renderVertical(textureId, x+fence_postsize, z+fence_postsize, x+fence_postsize, z-fence_postsize, y-0.5f, 1f, 4, 16, 6, 0);
		this.renderVertical(textureId, x+fence_postsize, z-fence_postsize, x-fence_postsize, z-fence_postsize, y-0.5f, 1f, 4, 16, 6, 0);
		this.renderVertical(textureId, x-fence_postsize, z-fence_postsize, x-fence_postsize, z+fence_postsize, y-0.5f, 1f, 4, 16, 6, 0);
		this.renderVertical(textureId, x-fence_postsize, z+fence_postsize, x+fence_postsize, z+fence_postsize, y-0.5f, 1f, 4, 16, 6, 0);
		this.renderHorizontal(textureId, x+fence_postsize, z+fence_postsize, x-fence_postsize, z-fence_postsize, y+0.5f, 4, 4, 6, 6, false);

		int adj_id;
		byte adj_data;

		// Check for adjacent fences / fence gates in the -x direction
		adj_id = this.getAdjNorthBlockId(xxx, yyy, zzz, blockOffset);
		if (adj_id == blockId)
		{
			// Fence to the North

			// Bottom slat
			this.renderVertical(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z+fence_postsize_h, slat_start, fence_slat_height, 16, 3, 0, 5);
			this.renderVertical(textureId, x-fence_postsize, z-fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start, fence_slat_height, 16, 3, 0, 5);
			this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start, 2, 16, 14, 0, false);
			this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start+fence_slat_height, 2, 16, 14, 0, false);

			// Top slat
			this.renderVertical(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z+fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 16, 3, 0, 5);
			this.renderVertical(textureId, x-fence_postsize, z-fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 16, 3, 0, 5);
			this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start+fence_top_slat_offset, 2, 16, 14, 0, false);
			this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-1f+fence_postsize, z-fence_postsize_h, slat_start+fence_top_slat_offset+fence_slat_height, 2, 16, 14, 0, false);
		}
		else if (adj_id > -1 && blockArray[adj_id] != null && blockArray[adj_id].type == BLOCK_TYPE.FENCE_GATE)
		{
			// Fence Gate to the North
			adj_data = this.getAdjNorthBlockData(xxx, yyy, zzz);
			if (adj_data != -1)
			{
				adj_data &= 0x3;
				if (adj_data == 0 || adj_data == 2)
				{
					// Bottom slat
					this.renderVertical(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z+fence_postsize_h, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize, z-fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start, 2, 6, 14, 0, false);
					this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start+fence_slat_height, 2, 6, 14, 0, false);

					// Top slat
					this.renderVertical(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z+fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 8, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize, z-fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 8, 3, 0, 5);
					this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset, 2, 8, 14, 0, false);
					this.renderHorizontal(textureId, x-fence_postsize, z+fence_postsize_h, x-.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset+fence_slat_height, 2, 8, 14, 0, false);
				}
			}
		}

		// Check for adjacent fence gates in the +x direction
		adj_id = this.getAdjSouthBlockId(xxx, yyy, zzz, blockOffset);
		if (adj_id > -1 && blockArray[adj_id] != null && blockArray[adj_id].type == BLOCK_TYPE.FENCE_GATE)
		{
			// Fence Gate to the South
			adj_data = this.getAdjSouthBlockData(xxx, yyy, zzz);
			if (adj_data != -1)
			{
				adj_data &= 0x3;
				if (adj_data == 0 || adj_data == 2)
				{
					// Bottom slat
					this.renderVertical(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z+fence_postsize_h, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x+fence_postsize, z-fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start, 2, 6, 14, 0, false);
					this.renderHorizontal(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start+fence_slat_height, 2, 6, 14, 0, false);

					// Top slat
					this.renderVertical(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z+fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 8, 3, 0, 5);
					this.renderVertical(textureId, x+fence_postsize, z-fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset, fence_slat_height, 8, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset, 2, 8, 14, 0, false);
					this.renderHorizontal(textureId, x+fence_postsize, z+fence_postsize_h, x+.5f, z-fence_postsize_h, slat_start+fence_top_slat_offset+fence_slat_height, 2, 8, 14, 0, false);
				}
			}
		}
		
		// Check for adjacent fences / fence gates in the -z direction
		adj_id = this.getAdjEastBlockId(xxx, yyy, zzz, blockOffset);
		if (adj_id == blockId)
		{
			// Bottom slat
			this.renderVertical(textureId, x+fence_postsize_h, z-fence_postsize, x+fence_postsize_h, z-1f+fence_postsize, slat_start, fence_slat_height, 16, 3, 0, 5);
			this.renderVertical(textureId, x-fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start, fence_slat_height, 16, 3, 0, 5);
			this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start, 2, 16, 14, 0, true);
			this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start+fence_slat_height, 2, 16, 14, 0, true);

			// Top slat
			this.renderVertical(textureId, x+fence_postsize_h, z-fence_postsize, x+fence_postsize_h, z-1f+fence_postsize, slat_start+fence_top_slat_offset, fence_slat_height, 16, 3, 0, 5);
			this.renderVertical(textureId, x-fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start+fence_top_slat_offset, fence_slat_height, 16, 3, 0, 5);
			this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start+fence_top_slat_offset, 2, 16, 14, 0, true);
			this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-1f+fence_postsize, slat_start+fence_top_slat_offset+fence_slat_height, 2, 16, 14, 0, true);
		}
		else if (adj_id > -1 && blockArray[adj_id] != null && blockArray[adj_id].type == BLOCK_TYPE.FENCE_GATE)
		{
			// Fence Gate to the East
			adj_data = this.getAdjEastBlockData(xxx, yyy, zzz);
			if (adj_data != -1)
			{
				adj_data &= 0x3;
				if (adj_data == 1 || adj_data == 3)
				{
					// Bottom slat
					this.renderVertical(textureId, x+fence_postsize_h, z-fence_postsize, x+fence_postsize_h, z-.5f, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start, 2, 6, 14, 0, true);
					this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start+fence_slat_height, 2, 6, 14, 0, true);

					// Top slat
					this.renderVertical(textureId, x+fence_postsize_h, z-fence_postsize, x+fence_postsize_h, z-.5f, slat_start+fence_top_slat_offset, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start+fence_top_slat_offset, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start+fence_top_slat_offset, 2, 6, 14, 0, true);
					this.renderHorizontal(textureId, x+fence_postsize_h, z-fence_postsize, x-fence_postsize_h, z-.5f, slat_start+fence_top_slat_offset+fence_slat_height, 2, 6, 14, 0, true);
				}
			}
		}

		// Check for adjacent fence gates in the +z direction
		adj_id = this.getAdjWestBlockId(xxx, yyy, zzz, blockOffset);
		if (adj_id > -1 && blockArray[adj_id] != null && blockArray[adj_id].type == BLOCK_TYPE.FENCE_GATE)
		{
			// Fence Gate to the West
			adj_data = this.getAdjWestBlockData(xxx, yyy, zzz);
			if (adj_data != -1)
			{
				adj_data &= 0x3;
				if (adj_data == 1 || adj_data == 3)
				{
					// Bottom slat
					this.renderVertical(textureId, x+fence_postsize_h, z+fence_postsize, x+fence_postsize_h, z+.5f, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start, 2, 6, 14, 0, true);
					this.renderHorizontal(textureId, x+fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start+fence_slat_height, 2, 6, 14, 0, true);

					// Top slat
					this.renderVertical(textureId, x+fence_postsize_h, z+fence_postsize, x+fence_postsize_h, z+.5f, slat_start+fence_top_slat_offset, fence_slat_height, 6, 3, 0, 5);
					this.renderVertical(textureId, x-fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start+fence_top_slat_offset, fence_slat_height, 6, 3, 0, 5);
					this.renderHorizontal(textureId, x+fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start+fence_top_slat_offset, 2, 6, 14, 0, true);
					this.renderHorizontal(textureId, x+fence_postsize_h, z+fence_postsize, x-fence_postsize_h, z+.5f, slat_start+fence_top_slat_offset+fence_slat_height, 2, 6, 14, 0, true);
				}
			}
		}
	}
	
	/**
	 * Renders a fence gate.  Good lord, this is a heck of a function.   I continually feel like I'm
	 * going about these things in the wrong way.  Ah, well - it works.
	 *
	 * TODO: Sort out the proper texture offsets + orientations, or at least do it consistently
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 * @param blockOffset Should be passed in from our main draw loop so we don't have to recalculate
	 */
	public void renderFenceGate(int textureId, int xxx, int yyy, int zzz, int blockOffset) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		float post_x1 = .375f;
		float post_x2 = .5f;
		float post_z = .0625f;
		float post_y_start = -.1875f;
		float post_h = .6875f;
		float middle_w = .125f;
		float middle_y = fence_slat_start_offset + fence_slat_height;
		float middle_h = fence_slat_start_offset + fence_top_slat_offset - middle_y;
		float middle_width = .0625f;

		byte data = getData(xxx, yyy, zzz);
		boolean open = ((data & 0x4) == 0x4);
		int dir = (data & 0x3);

		// GL stuff; only draw one way
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);
		switch (dir)
		{
			case 1:
				GL11.glRotatef(270f, 0f, 1f, 0f);
				break;
			case 2:
				GL11.glRotatef(180f, 0f, 1f, 0f);
				break;
			case 3:
				GL11.glRotatef(90f, 0f, 1f, 0f);
				break;
			case 0:
			default:
				break;
		}

		// One side post
		this.renderVertical(textureId, post_x1, post_z, post_x2, post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, post_x1, -post_z, post_x2, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, post_x1, post_z, post_x1, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, post_x2, post_z, post_x2, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderHorizontal(textureId, post_x1, post_z, post_x2, -post_z, post_y_start, 2, 2, 7, 7, false);
		this.renderHorizontal(textureId, post_x1, post_z, post_x2, -post_z, post_y_start+post_h, 2, 2, 7, 7, false);
		
		// The other side post
		this.renderVertical(textureId, -post_x1, post_z, -post_x2, post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, -post_x1, -post_z, -post_x2, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, -post_x1, post_z, -post_x1, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderVertical(textureId, -post_x2, post_z, -post_x2, -post_z, post_y_start, post_h, 2, 11, 7, 0);
		this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, -post_z, post_y_start, 2, 2, 7, 7, false);
		this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, -post_z, post_y_start+post_h, 2, 2, 7, 7, false);

		// Now the gate itself
		if (open)
		{
			// One side, bottom slat
			this.renderVertical(textureId, post_x1, post_z, post_x1, .48f, fence_slat_start_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderVertical(textureId, post_x2, post_z, post_x2, .48f, fence_slat_start_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderHorizontal(textureId, post_x1, post_z, post_x2, .48f, fence_slat_start_offset, 6, 2, 5, 7, true);
			this.renderHorizontal(textureId, post_x1, post_z, post_x2, .48f, fence_slat_start_offset+fence_slat_height, 6, 2, 5, 7, false);

			// One side, top slat
			this.renderVertical(textureId, post_x1, post_z, post_x1, .48f, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderVertical(textureId, post_x2, post_z, post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderHorizontal(textureId, post_x1, post_z, post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset, 6, 2, 5, 7, true);
			this.renderHorizontal(textureId, post_x1, post_z, post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset+fence_slat_height, 6, 2, 5, 7, false);

			// One side, middle bit
			this.renderVertical(textureId, post_x1, .48f, post_x1, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, post_x2, .48f, post_x2, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, post_x1, .48f-middle_w, post_x2, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, post_x1, .48f, post_x2, .48f, fence_slat_start_offset, fence_slat_height+fence_top_slat_offset, 2, 9, 7, 0);

			// Other side, bottom slat
			this.renderVertical(textureId, -post_x1, post_z, -post_x1, .48f, fence_slat_start_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderVertical(textureId, -post_x2, post_z, -post_x2, .48f, fence_slat_start_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, .48f, fence_slat_start_offset, 6, 2, 5, 7, true);
			this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, .48f, fence_slat_start_offset+fence_slat_height, 6, 2, 5, 7, false);

			// Other side, top slat
			this.renderVertical(textureId, -post_x1, post_z, -post_x1, .48f, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderVertical(textureId, -post_x2, post_z, -post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 6, 3, 5, 7);
			this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset, 6, 2, 5, 7, true);
			this.renderHorizontal(textureId, -post_x1, post_z, -post_x2, .48f, fence_slat_start_offset+fence_top_slat_offset+fence_slat_height, 6, 2, 5, 7, false);

			// Other side, middle bit
			this.renderVertical(textureId, -post_x1, .48f, -post_x1, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, -post_x2, .48f, -post_x2, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, -post_x1, .48f-middle_w, -post_x2, .48f-middle_w, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, -post_x1, .48f, -post_x2, .48f, fence_slat_start_offset, fence_slat_height+fence_top_slat_offset, 2, 9, 7, 0);
		}
		else
		{
			// Bottom bar
			this.renderVertical(textureId, post_x1, post_z, -post_x1, post_z, fence_slat_start_offset, fence_slat_height, 12, 3, 2, 7);
			this.renderVertical(textureId, post_x1, -post_z, -post_x1, -post_z, fence_slat_start_offset, fence_slat_height, 12, 3, 2, 7);
			this.renderHorizontal(textureId, post_x1, post_z, -post_x1, -post_z, fence_slat_start_offset, 12, 2, 2, 3, true);
			this.renderHorizontal(textureId, post_x1, post_z, -post_x1, -post_z, fence_slat_start_offset+fence_slat_height, 12, 2, 2, 3, true);

			// Top bar
			this.renderVertical(textureId, post_x1, post_z, -post_x1, post_z, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 12, 3, 2, 7);
			this.renderVertical(textureId, post_x1, -post_z, -post_x1, -post_z, fence_slat_start_offset+fence_top_slat_offset, fence_slat_height, 12, 3, 2, 7);
			this.renderHorizontal(textureId, post_x1, post_z, -post_x1, -post_z, fence_slat_start_offset+fence_top_slat_offset, 12, 2, 2, 3, true);
			this.renderHorizontal(textureId, post_x1, post_z, -post_x1, -post_z, fence_slat_start_offset+fence_top_slat_offset+fence_slat_height, 12, 2, 2, 3, true);

			// Middle bit
			this.renderVertical(textureId, middle_w, post_z, -middle_w, post_z, middle_y, middle_h, 4, 3, 6, 5);
			this.renderVertical(textureId, middle_w, -post_z, -middle_w, -post_z, middle_y, middle_h, 4, 3, 6, 5);
			this.renderVertical(textureId, middle_w, middle_width, middle_w, -middle_width, middle_y, middle_h, 2, 3, 7, 5);
			this.renderVertical(textureId, -middle_w, middle_width, -middle_w, -middle_width, middle_y, middle_h, 2, 3, 7, 5);
		}

		// aaand pop our GL matrix
		GL11.glPopMatrix();
	}

	/**
	 * Renders a button.
	 */
	public void renderButton(int textureId, int xxx, int yyy, int zzz) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		
		float faceX1, faceX2;
		float faceZ1, faceZ2;
		float back_dX, back_dZ;
		float button_radius = .1f;
		
		byte data = getData(xxx, yyy, zzz);
		switch(data)
		{
		 	case 1:
	 			// South
		 		faceX1 = x-0.5f+button_radius;
		 		faceX2 = x-0.5f+button_radius;
		 		faceZ1 = z-button_radius;
		 		faceZ2 = z+button_radius;
		 		back_dX = -button_radius;
		 		back_dZ = 0;
	 			break;
		 	case 2:
		 		// North
		 		faceX1 = x+0.5f-button_radius;
		 		faceX2 = x+0.5f-button_radius;
		 		faceZ1 = z-button_radius;
		 		faceZ2 = z+button_radius;
		 		back_dX = button_radius;
		 		back_dZ = 0;
		 		break;
		 	case 3:
		 		// West
		 		faceX1 = x-button_radius;
		 		faceX2 = x+button_radius;
		 		faceZ1 = z-0.5f+button_radius;
		 		faceZ2 = z-0.5f+button_radius;
		 		back_dX = 0;
		 		back_dZ = -button_radius;
		 		break;
		 	case 4:
	 		default:
		 		// East
		 		faceX1 = x-button_radius;
		 		faceX2 = x+button_radius;
		 		faceZ1 = z+0.5f-button_radius;
		 		faceZ2 = z+0.5f-button_radius;
		 		back_dX = 0;
		 		back_dZ = button_radius;
		 		break;
		}
		
		// Button face
		this.renderVertical(textureId, faceX1, faceZ1, faceX2, faceZ2, y-button_radius, button_radius*2);
		
		// Sides
		this.renderVertical(textureId, faceX1, faceZ1, faceX1+back_dX, faceZ1+back_dZ, y-button_radius, button_radius*2);
		this.renderVertical(textureId, faceX2, faceZ2, faceX2+back_dX, faceZ2+back_dZ, y-button_radius, button_radius*2);
		
		// Top/Bottom
		this.renderHorizontal(textureId, faceX1, faceZ1, faceX2+back_dX, faceZ2+back_dZ, y-button_radius);
		this.renderHorizontal(textureId, faceX1, faceZ1, faceX2+back_dX, faceZ2+back_dZ, y+button_radius);

	}
	
	/**
	 * Portal square rendering.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 * @param blockOffset Should be passed in from our main draw loop so we don't have to recalculate
	 */
	public void renderPortal(int textureId, int xxx, int yyy, int zzz, int blockOffset, int blockId) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		
		// Check to see where adjoining Portal spaces are, so we know which
		// faces to draw
		boolean drawWestEast = true;
		if (this.getAdjNorthBlockId(xxx, yyy, zzz, blockOffset) == blockId ||
				this.getAdjSouthBlockId(xxx, yyy, zzz, blockOffset) == blockId)
		{
			drawWestEast = false;
		}

		if (drawWestEast)
		{
			this.renderVertical(textureId, x-0.3f, z-0.5f, x-0.3f, z+0.5f, y-0.5f, 1.0f);
			this.renderVertical(textureId, x+0.3f, z-0.5f, x+0.3f, z+0.5f, y-0.5f, 1.0f);
		}
		else
		{
			this.renderVertical(textureId, x-0.5f, z-0.3f, x+0.5f, z-0.3f, y-0.5f, 1.0f);
			this.renderVertical(textureId, x-0.5f, z+0.3f, x+0.5f, z+0.3f, y-0.5f, 1.0f);
		}
	}
	
	/**
	 * This is a bizarre little method, and should probably be both renamed and refactored
	 * into some functions that make more sense.  It's used in a few places to determine
	 * which faces of a block we're supposed to actually render.  "transparency" is whether
	 * or not we're currently rendering transparent objects.
	 */
	public boolean checkSolid(short block) {
		if(block <= 0) {
			return true;
		}
		if (blockArray[block] == null)
		{
			return false;
		}
		return !blockArray[block].isSolid();
	}

	/**
	 * This method, on the other hand, is a bit more clear.  We'll return true if the
	 * block ID is solid.
	 */
	public boolean isSolid(short block)
	{
		if(block <= 0) {
			return false;
		}
		if (blockArray[block] == null)
		{
			return false;
		}
		return blockArray[block].isSolid();
	}
	
	/**
	 * Renders the body of a piston.  If the piston is retracted, we'll also make a call out
	 * to renderPistonHead to draw the actual head.  Note that we do need to have the block
	 * type passed in, so that we can tell renderPistonHead what texture to draw.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 * @param block The actual BlockType object; needed for the piston head
	 */
	public void renderPistonBody(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		byte data = getData(xxx, yyy, zzz);
		boolean extended = ((data & 0x8) == 0x8);
		int direction = (data & 0x7);

		float tex_x = precalcSpriteSheetToTextureX[textureId];
		float tex_y = precalcSpriteSheetToTextureY[textureId]+TEX128;
		float TEX_PISTON = TEX128*3f;

		// Use GL to rotate these properly
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);

		// This routine draws the piston facing west, which is direction value 3
		if (direction == 1)
		{
			// Up
			GL11.glRotatef(-90f, 1f, 0f, 0f);
		}
		else if (direction == 2)
		{
			// East
			GL11.glRotatef(180f, 0f, 1f, 0f);
		}
		else if (direction == 4)
		{
			// North
			GL11.glRotatef(-90f, 0f, 1f, 0f);
		}
		else if (direction == 5)
		{
			// South
			GL11.glRotatef(90f, 0f, 1f, 0f);
		}

		// First the main body bit
		renderNonstandardHorizontal(tex_x, tex_y, TEX16, TEX_PISTON, -.49f, .25f, .49f, -.49f, .49f);
		renderNonstandardHorizontal(tex_x, tex_y, TEX16, TEX_PISTON, -.49f, .25f, .49f, -.49f, -.49f);
		renderNonstandardVertical(tex_x, tex_y, TEX16, TEX_PISTON, -.49f, .49f, .25f, -.49f, -.49f, -.49f);
		renderNonstandardVertical(tex_x, tex_y, TEX16, TEX_PISTON, .49f, .49f, .25f, .49f, -.49f, -.49f);
		renderVertical(block.texture_extra_map.get("back"), -.49f, -.49f, .49f, -.49f, -.49f, .98f);

		// If we're extended, draw our faceplate; if not, draw the retracted face
		if (extended)
		{
			renderVertical(block.texture_extra_map.get("front"), -.49f, .25f, .49f, .25f, -.49f, .98f);

			// Pop the matrix after
			GL11.glPopMatrix();
		}
		else
		{
			// Pop the matrix before
			GL11.glPopMatrix();

			renderPistonHead(block.texture_extra_map.get("head"), xxx, yyy, zzz, BLOCK_PISTON_HEAD, true, (block.id == BLOCK_PISTON_STICKY_BODY.id));
		}

	}

	/**
	 * Renders the head of a piston.  This can get called from either the main loop, or from
	 * renderPistonBody.  If called from renderPistonBody, "attached" should be set to true,
	 * so we know not to draw the back face and post.  The override_sticky boolean should be
	 * used (when attached is true) to specify whether to use the sticky-piston texture or
	 * not, since the data value we read will be the Body's data value, which does not
	 * indicate stickiness.  Fortunately, the remaining three bits (the direction) matches
	 * up between head and body, so we should be okay just reading the body's data for
	 * direction information.
	 *
	 * The textureId passed in should be the ID of the non-sticky texture; some logic here
	 * depends on the layout of the texture information in terrain.png
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 * @param attached Are we attached to the piston body?
	 * @param override_sticky If attached, are we a sticky piston or a regular piston?
	 */
	public void renderPistonHead(int textureId, int xxx, int yyy, int zzz, BlockType block, boolean attached, boolean override_sticky) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		byte data = getData(xxx, yyy, zzz);
		boolean sticky = ((data & 0x8) == 0x8);
		int direction = (data & 0x7);

		float side_tex_x = precalcSpriteSheetToTextureX[block.texture_extra_map.get("body")];
		float side_tex_y = precalcSpriteSheetToTextureY[block.texture_extra_map.get("body")];

		// Matrix stuff
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);

		// This routine draws the piston facing west, which is direction value 3
		if (direction == 1)
		{
			// Up
			GL11.glRotatef(-90f, 1f, 0f, 0f);
		}
		else if (direction == 2)
		{
			// East
			GL11.glRotatef(180f, 0f, 1f, 0f);
		}
		else if (direction == 4)
		{
			// North
			GL11.glRotatef(-90f, 0f, 1f, 0f);
		}
		else if (direction == 5)
		{
			// South
			GL11.glRotatef(90f, 0f, 1f, 0f);
		}

		// Outside edges
		renderNonstandardHorizontalTexRotate(side_tex_x, side_tex_y, TEX16, TEX128, -.49f, .25f, .49f, .49f, .49f);
		renderNonstandardHorizontalTexRotate(side_tex_x, side_tex_y, TEX16, TEX128, -.49f, .25f, .49f, .49f, -.49f);
		renderNonstandardVerticalTexRotate(side_tex_x, side_tex_y, TEX16, TEX128, -.49f, .49f, .25f, -.49f, -.49f, .49f);
		renderNonstandardVerticalTexRotate(side_tex_x, side_tex_y, TEX16, TEX128, .49f, .49f, .25f, .49f, -.49f, .49f);

		// Back face and post, if we're not attached
		if (!attached)
		{
			// Back face first
			renderVertical(textureId, -.49f, .25f, .49f, .25f, -.49f, .98f);

			// Now the post
			renderNonstandardHorizontal(side_tex_x, side_tex_y, TEX16, TEX128, -.125f, .25f, .125f, -.75f, .125f);
			renderNonstandardHorizontal(side_tex_x, side_tex_y, TEX16, TEX128, -.125f, .25f, .125f, -.75f, -.125f);
			renderNonstandardVertical(side_tex_x, side_tex_y, TEX16, TEX128, -.125f, .125f, .25f, -.125f, -.125f, -.75f);
			renderNonstandardVertical(side_tex_x, side_tex_y, TEX16, TEX128, .125f, .125f, .25f, .125f, -.125f, -.75f);
		}

		// Front face
		if (attached)
		{
			if (override_sticky)
			{
				textureId = block.texture_extra_map.get("head_sticky");
			}
		}
		else
		{
			if (sticky)
			{
				textureId = block.texture_extra_map.get("head_sticky");
			}
		}
		renderVertical(textureId, -.49f, .49f, .49f, .49f, -.49f, .98f);

		// Pop the matrix
		GL11.glPopMatrix();
	}
	
	/**
	 * Renders a cake
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderCake(int textureId, int xxx, int yyy, int zzz, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		byte bites_eaten = getData(xxx, yyy, zzz);

		int bottom_tex_idx = block.texture_extra_map.get("bottom");
		int edge_tex_idx = block.texture_extra_map.get("side_uncut");
		int cut_tex_idx = block.texture_extra_map.get("side_cut");

		float top_tex_x = precalcSpriteSheetToTextureX[textureId]+TEX256;
		float top_tex_y = precalcSpriteSheetToTextureY[textureId]+TEX512;
		float bottom_tex_x = precalcSpriteSheetToTextureX[bottom_tex_idx]+TEX256;
		float bottom_tex_y = precalcSpriteSheetToTextureY[bottom_tex_idx]+TEX512;
		float edge_tex_x = precalcSpriteSheetToTextureX[edge_tex_idx]+TEX256;
		float edge_tex_y = precalcSpriteSheetToTextureY[edge_tex_idx]+TEX64;
		float cut_tex_x = precalcSpriteSheetToTextureX[cut_tex_idx]+TEX256;
		float cut_tex_y = precalcSpriteSheetToTextureY[cut_tex_idx]+TEX64;

		float far_tex_x, far_tex_y;
		if (bites_eaten == 0)
		{
			far_tex_x = edge_tex_x;
			far_tex_y = edge_tex_y;
		}
		else
		{
			far_tex_x = cut_tex_x;
			far_tex_y = cut_tex_y;
		}


		float tex_full_width = TEX256*14f;
		float tex_full_height = TEX512*14f;
		float tex_side_height = TEX64;
		float cake_height = .5f;
		float cake_full_width = .875f;
		float cake_full_width_h = .4375f;

		float actual_width = (6f-(float)bites_eaten)/6f;

		// Use GL to rotate these properly
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);

		// Note that cake will always be eaten from the North
		// Knowing that, draw the south face, first
		renderNonstandardVertical(edge_tex_x, edge_tex_y, tex_full_width, tex_side_height,
				cake_full_width_h, 0f, cake_full_width_h,
				cake_full_width_h, -.49f, -cake_full_width_h);

		// Draw the far edge next
		renderNonstandardVertical(far_tex_x, far_tex_y, tex_full_width, tex_side_height,
				cake_full_width_h-(actual_width*cake_full_width), 0f, cake_full_width_h,
				cake_full_width_h-(actual_width*cake_full_width), -.49f, -cake_full_width_h);

		// And now the sides
		renderNonstandardVertical(edge_tex_x, edge_tex_y, tex_full_width*actual_width, tex_side_height,
				cake_full_width_h, 0f, cake_full_width_h,
				cake_full_width_h-(actual_width*cake_full_width), -.49f, cake_full_width_h);
		renderNonstandardVertical(edge_tex_x, edge_tex_y, tex_full_width*actual_width, tex_side_height,
				cake_full_width_h, 0f, -cake_full_width_h,
				cake_full_width_h-(actual_width*cake_full_width), -.49f, -cake_full_width_h);

		// Now the bottom
		renderNonstandardHorizontal(bottom_tex_x, bottom_tex_y, tex_full_width, tex_full_height*actual_width,
				cake_full_width_h, cake_full_width_h,
				cake_full_width_h-(actual_width*cake_full_width), -cake_full_width_h,
				-.49f);

		// ... and the top
		renderNonstandardHorizontal(top_tex_x, top_tex_y, tex_full_width, tex_full_height*actual_width,
				cake_full_width_h, cake_full_width_h,
				cake_full_width_h-(actual_width*cake_full_width), -cake_full_width_h,
				0f);

		// Pop the matrix
		GL11.glPopMatrix();
	}
	
	/**
	 * Renders a sold pane-like object (glass pane, iron bars, etc)
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderSolidPane(int textureId, int xxx, int yyy, int zzz, int blockOffset, int blockId) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		boolean has_north = false;
		boolean has_south = false;
		boolean has_west = false;
		boolean has_east = false;

		float top_width = .0625f;
		int top_row_1 = 0;
		int top_row_2 = 15;
		if (blockId == BLOCK_IRON_BARS.id)
		{
			top_row_1 = 2;
			top_row_2 = 3;
		}

		short temp_id;
		temp_id = this.getAdjNorthBlockId(xxx, yyy, zzz, blockOffset);
		if (temp_id == blockId || this.isSolid(temp_id))
		{
			has_north = true;
		}
		temp_id = this.getAdjSouthBlockId(xxx, yyy, zzz, blockOffset);
		if (temp_id == blockId || this.isSolid(temp_id))
		{
			has_south = true;
		}
		temp_id = this.getAdjWestBlockId(xxx, yyy, zzz, blockOffset);
		if (temp_id == blockId || this.isSolid(temp_id))
		{
			has_west = true;
		}
		temp_id = this.getAdjEastBlockId(xxx, yyy, zzz, blockOffset);
		if (temp_id == blockId || this.isSolid(temp_id))
		{
			has_east = true;
		}

		if (!has_north && !has_south && !has_west && !has_east)
		{
			has_north = true;
			has_south = true;
			has_west = true;
			has_east = true;
		}

		// Now we should be able to actually draw stuff
		if (has_north && has_south)
		{
			this.renderVertical(textureId, x-.5f, z, x+.5f, z, y-.5f, .98f);
		}
		else
		{
			if (has_north)
			{
				this.renderVertical(textureId, x, z, x-.5f, z, y-.5f, .98f, 8, 16, 8, 0);
			}
			if (has_south)
			{
				this.renderVertical(textureId, x, z, x+.5f, z, y-.5f, .98f, 8, 16, 8, 0);
			}
		}
		if (has_north)
		{
			this.renderHorizontal(textureId, x-.5f, z+top_width, x-top_width, z, y+.48f, 1, 7, top_row_1, 0, false);
			this.renderHorizontal(textureId, x-.5f, z-top_width, x-top_width, z, y+.48f, 1, 7, top_row_2, 0, false);
		}
		if (has_south)
		{
			this.renderHorizontal(textureId, x+.5f, z+top_width, x+top_width, z, y+.48f, 1, 7, top_row_1, 0, false);
			this.renderHorizontal(textureId, x+.5f, z-top_width, x+top_width, z, y+.48f, 1, 7, top_row_2, 0, false);
		}

		if (has_west && has_east)
		{
			this.renderVertical(textureId, x, z-.5f, x, z+.5f, y-.5f, .98f);
		}
		else
		{
			if (has_west)
			{
				this.renderVertical(textureId, x, z, x, z+.5f, y-.5f, .98f, 8, 16, 8, 0);
			}
			if (has_east)
			{
				this.renderVertical(textureId, x, z, x, z-.5f, y-.5f, .98f, 8, 16, 8, 0);
			}
		}
		if (has_west)
		{
			this.renderHorizontal(textureId, x+top_width, z+.5f, x, z+top_width, y+.48f, 1, 7, top_row_1, 0, true);
			this.renderHorizontal(textureId, x-top_width, z+.5f, x, z+top_width, y+.48f, 1, 7, top_row_2, 0, true);
		}
		if (has_east)
		{
			this.renderHorizontal(textureId, x+top_width, z-.5f, x, z-top_width, y+.48f, 1, 7, top_row_1, 0, true);
			this.renderHorizontal(textureId, x-top_width, z-.5f, x, z-top_width, y+.48f, 1, 7, top_row_2, 0, true);
		}

		// Finally, the center top square.  Technically we shouldn't draw past the edge, but whatever.
		this.renderHorizontal(textureId, x+top_width, z+top_width, x-top_width, z, y+.48f, 1, 2, top_row_1, 7, false);
		this.renderHorizontal(textureId, x+top_width, z-top_width, x-top_width, z, y+.48f, 1, 2, top_row_2, 7, false);
	}
	
	/**
	 * Renders a chest
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderChest(int textureId, int xxx, int yyy, int zzz, int blockOffset, BlockType block) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		float edges = .45f;
		float bottom = .49f;
		float height = .94f;
		float full = .5f;

		byte orientation = getData(xxx, yyy, zzz);

		// Use GL to rotate these properly
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, z);

		// Find out if we have adjacent chests, and rotate.  Our "have_right" and
		// "have_left" booleans are a little bit at odds with the orientation of the
		// chest itself, since my "left/right" is looking *at* the front of the
		// chest, not pointing out in the direction the chest is facing.  Alas.
		boolean have_left = false;
		boolean have_right = false;
		switch(orientation)
		{
			case 4:
				// Facing North
				have_right = (getAdjWestBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				have_left = (getAdjEastBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				GL11.glRotatef(270f, 0f, 1f, 0f);
				break;
			case 5:
				// Facing South
				have_right = (getAdjEastBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				have_left = (getAdjWestBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				GL11.glRotatef(90f, 0f, 1f, 0f);
				break;
			case 2:
				// Facing east
				have_right = (getAdjNorthBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				have_left = (getAdjSouthBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				GL11.glRotatef(180f, 0f, 1f, 0f);
				break;
			case 3:
			default:
				// Facing west (this is what chests with a data of "0" will show up as,
				// weirdly, in Minecraft itself)
				have_right = (getAdjSouthBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				have_left = (getAdjNorthBlockId(xxx, yyy, zzz, blockOffset) == block.id);
				break;
		}

		// Render appropriately
		if (have_left)
		{
			renderVertical(block.texture_extra_map.get("front_big_right"), -full, edges, edges, edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("back_big_right"), -full, -edges, edges, -edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("side_small"), edges, -edges, edges, edges, -bottom, height);
			renderHorizontal(block.texture_extra_map.get("top"), -full, -edges, edges, edges, edges, 8, 16, 8, 0, true);
			renderHorizontal(block.texture_extra_map.get("top"), -full, -edges, edges, edges, -bottom, 8, 16, 8, 0, true);
		}
		else if (have_right)
		{
			renderVertical(block.texture_extra_map.get("front_big_left"), -edges, edges, full, edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("back_big_left"), -edges, -edges, full, -edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("side_small"), -edges, -edges, -edges, edges, -bottom, height);
			renderHorizontal(block.texture_extra_map.get("top"), -edges, -edges, full, edges, edges, 8, 16, 0, 0, true);
			renderHorizontal(block.texture_extra_map.get("top"), -edges, -edges, full, edges, -bottom, 8, 16, 0, 0, true);
		}
		else
		{
			renderVertical(textureId, -edges, edges, edges, edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("side_small"), -edges, -edges, edges, -edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("side_small"), -edges, -edges, -edges, edges, -bottom, height);
			renderVertical(block.texture_extra_map.get("side_small"), edges, -edges, edges, edges, -bottom, height);
			renderHorizontal(block.texture_extra_map.get("top"), -edges, -edges, edges, edges, edges);
			renderHorizontal(block.texture_extra_map.get("top"), -edges, -edges, edges, edges, -bottom);
		}

		// Pop the matrix
		GL11.glPopMatrix();
	}

	/**
	 * Helper function for renderHalfHeight - given an adjacent block ID, it
	 * will return true if we should render that "side"
	 */
	public boolean shouldRenderHalfHeightAdj(short adj_block)
	{
		if (adj_block < 0)
		{
			return true;
		}
		if (blockArray[adj_block] == null)
		{
			return true;
		}
		return (!blockArray[adj_block].isSolid() &&
				blockArray[adj_block].type != BLOCK_TYPE.HALFHEIGHT);
	}
	
	/**
	 * Renders a half-height block
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderHalfHeight(int textureId, int xxx, int yyy, int zzz, int blockOffset) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;

		// Sides
		if (shouldRenderHalfHeightAdj(getAdjEastBlockId(xxx, yyy, zzz, blockOffset)))
		{
			this.renderWestEast(textureId, x, y, z, 0f, .5f);
		}
		if (shouldRenderHalfHeightAdj(getAdjWestBlockId(xxx, yyy, zzz, blockOffset)))
		{
			this.renderWestEast(textureId, x, y, z+1, 0f, .5f);
		}
		if (shouldRenderHalfHeightAdj(getAdjNorthBlockId(xxx, yyy, zzz, blockOffset)))
		{
			this.renderNorthSouth(textureId, x, y, z, 0f, .5f);
		}
		if (shouldRenderHalfHeightAdj(getAdjSouthBlockId(xxx, yyy, zzz, blockOffset)))
		{
			this.renderNorthSouth(textureId, x+1, y, z, 0f, .5f);
		}
		
		// Bottom
		boolean render_bottom = true;
		if (y > 0)
		{
			short bottom = blockData.value[blockOffset-1];
			render_bottom = (bottom == 0 || (bottom > 0 && blockArray[bottom] != null && !blockArray[bottom].isSolid()));
		}
		if (render_bottom)
		{
			this.renderTopDown(textureId, x, y, z);
		}

		// Always render the top
		this.renderTopDown(textureId, x, y+0.5f, z);	
	}
	
	/**
	 * Renders a semisolid or water block
	 *
	 * TODO: We're doing some ridiculousness here to avoid z-fighting when we're is up against
	 * halfheight blocks.  When we draw our face on top of an already-existing face with
	 * the exact same geometry (say, a "full" solid block), the textures combine perfectly and
	 * we're all happy.  If the polygons are at all differently-sized, though, we get z-fighting
	 * and it's terrible.  I'd love to know why that is (or, more to the point, why we *don't*
	 * get z-fighting when the geometry is equal).  Apparently if we move to using shaders,
	 * using multitexturing is pretty easy, so we may want to look at doing that.  Whatever that
	 * actually is.  Someday I should learn how to actually use this stuff, yeah?
	 *
	 * TODO: sight, West and South halfheight stuff doesn't seem to actually render for some reason,
	 * it gets overwritten by the halfheight texture itself.  I'd love to figure out why all of
	 * this is happening.  Still, IMO it's better than the z-fighting, so for now I'll leave it.
	 * 
	 * @param textureId
	 * @param xxx
	 * @param yyy
	 * @param zzz
	 */
	public void renderSemisolid(int textureId, int xxx, int yyy, int zzz, int blockOffset, int blockId) {
		float x = xxx + this.x*16;
		float z = zzz + this.z*16;
		float y = yyy;
		short adj;

		// Sides
		adj = getAdjEastBlockId(xxx, yyy, zzz, blockOffset);
		if (adj != blockId)
		{
			if (adj > 0 && blockArray[adj] != null && blockArray[adj].type == BLOCK_TYPE.HALFHEIGHT)
			{
				this.renderVertical(textureId, x-.5f, z-.5f, x+.5f, z-.5f, y, .5f, 16, 8, 0, 0);
				this.renderVertical(textureId, x-.5f, z-.5f, x+.5f, z-.5f, y-.5f, .5f, 16, 8, 0, 8);
			}
			else
			{
				this.renderVertical(textureId, x-.5f, z-.5f, x+.5f, z-.5f, y-.5f, 1f);
			}
		}
		adj = getAdjWestBlockId(xxx, yyy, zzz, blockOffset);
		if (adj != blockId)
		{
			if (adj > 0 && blockArray[adj] != null && blockArray[adj].type == BLOCK_TYPE.HALFHEIGHT)
			{
				this.renderVertical(textureId, x-.5f, z+.5f, x+.5f, z+.5f, y, .5f, 16, 8, 0, 0);
				this.renderVertical(textureId, x-.5f, z+.5f, x+.5f, z+.5f, y-.5f, .5f, 16, 8, 0, 8);
			}
			else
			{
				this.renderVertical(textureId, x-.5f, z+.5f, x+.5f, z+.5f, y-.5f, 1f);
			}
		}
		adj = getAdjNorthBlockId(xxx, yyy, zzz, blockOffset);
		if (adj != blockId)
		{
			if (adj > 0 && blockArray[adj] != null && blockArray[adj].type == BLOCK_TYPE.HALFHEIGHT)
			{
				this.renderVertical(textureId, x-.5f, z+.5f, x-.5f, z-.5f, y, .5f, 16, 8, 0, 0);
				this.renderVertical(textureId, x-.5f, z+.5f, x-.5f, z-.5f, y-.5f, .5f, 16, 8, 0, 8);
			}
			else
			{
				this.renderVertical(textureId, x-.5f, z+.5f, x-.5f, z-.5f, y-.5f, 1f);
			}
		}
		adj = getAdjSouthBlockId(xxx, yyy, zzz, blockOffset);
		if (adj != blockId)
		{
			if (adj > 0 && blockArray[adj] != null && blockArray[adj].type == BLOCK_TYPE.HALFHEIGHT)
			{
				this.renderVertical(textureId, x+.5f, z+.5f, x+.5f, z-.5f, y, .5f, 16, 8, 0, 0);
				this.renderVertical(textureId, x+.5f, z+.5f, x+.5f, z-.5f, y-.5f, .5f, 16, 8, 0, 8);
			}
			else
			{
				this.renderVertical(textureId, x+.5f, z+.5f, x+.5f, z-.5f, y-.5f, 1f);
			}
		}
		
		// Bottom
		boolean render_bottom = true;
		if (y > 0)
		{
			render_bottom = blockData.value[blockOffset-1] != blockId;
		}
		if (render_bottom)
		{
			this.renderTopDown(textureId, x, y, z);
		}

		// Top
		boolean render_top = true;
		if (y < 127)
		{
			render_top = blockData.value[blockOffset+1] != blockId;
		}
		if (render_top)
		{
			this.renderTopDown(textureId, x, y+1f, z);
		}
	}
	
	/**
	 * Tests if the given source block has a torch nearby.  This is, I'm willing
	 * to bet, the least efficient way possible of doing this.  It turns out that
	 * despite that, it doesn't really have a noticeable impact on performance,
	 * which is why it remains in here, but perhaps one day I'll rewrite this
	 * stuff to be less stupid.  The one upside to doing it like this is that
	 * we're not using any extra memory storing data about which block should be
	 * highlighted...
	 * 
	 * @param sx
	 * @param sy
	 * @param sz
	 * @return
	 */
	public boolean hasAdjacentTorch(int sx, int sy, int sz)
	{
		int distance = 3;
		int x, y, z;
		int min_x = sx-distance;
		int max_x = sx+distance;
		int min_z = sz-distance;
		int max_z = sz+distance;
		int min_y = Math.max(0, sy-distance);
		int max_y = Math.min(127, sy+distance);
		Chunk otherChunk;
		int cx, cz;
		int tx, tz;
		for (x = min_x; x<=max_x; x++)
		{
			for (y = min_y; y<=max_y; y++)
			{
				for (z = min_z; z<=max_z; z++)
				{
					otherChunk = null;
					if (x < 0)
					{
						cx = this.x-1;
						tx = 16+x;
					}
					else if (x > 15)
					{
						cx = this.x+1;
						tx = x-16;
					}
					else
					{
						cx = this.x;
						tx = x;
					}

					if (z < 0)
					{
						cz = this.z-1;
						tz = 16+z;
					}
					else if (z > 15)
					{
						cz = this.z+1;
						tz = z-16;
					}
					else
					{
						cz = this.z;
						tz = z;
					}
					
					if (cx != this.x || cz != this.z)
					{
						otherChunk = level.getChunk(cx, cz);
						if (otherChunk == null)
						{
							continue;
						}
						else if (otherChunk.blockData.value[(tz*128)+(tx*128*16)+y] == BLOCK_TORCH.id)
						{
							return true;
						}
					}
					else
					{
						if (blockData.value[(z*128)+(x*128*16)+y] == BLOCK_TORCH.id)
						{
							return true;
						}
					}
				}
			}
		}
		return false;
	}

	public void renderWorldSolids(int sheet, boolean render_bedrock, boolean highlight_explored)
	{
		renderWorld(RENDER_PASS.SOLIDS, sheet, render_bedrock, false, highlight_explored, null);
	}

	public void renderWorldNonstandard(int sheet, boolean render_water, boolean highlight_explored)
	{
		renderWorld(RENDER_PASS.NONSTANDARD, sheet, false, render_water, highlight_explored, null);
	}

	public void renderWorldGlass(int sheet, boolean highlight_explored)
	{
		renderWorld(RENDER_PASS.GLASS, sheet, false, false, highlight_explored, null);
	}

	public void renderWorldSelected(int sheet, boolean[] selectedMap)
	{
		renderWorld(RENDER_PASS.SELECTED, sheet, false, false, false, selectedMap);
	}
	
	/**
	 * Renders our chunk.  Most of these options should really be consolidated somehow; maybe just pass in
	 * a HashMap or something with the options.  Anyway, for now it'll remain the same.
	 * 
	 * @param pass What pass of rendering are we processing?
	 * @param sheet Which texture sheet are we currently rendering?
	 * @param render_bedrock Are we forcing bedrock to be rendered?
	 * @param render_water Are we forcing water to be rendered?
	 * @param highlight_explored Are we highlighting the area around torches?
	 * @param selectedMap ... if so, here's a HashMap to which ones to highlight.
	 */
	public void renderWorld(RENDER_PASS pass, int sheet,
			boolean render_bedrock, boolean render_water,
			boolean highlight_explored,
			boolean[] selectedMap) {

		float worldX = this.x*16;
		float worldZ = this.z*16;
		
		boolean draw = false;
		boolean above = true;
		boolean below = true;
		boolean north = true;
		boolean south = true;
		boolean east = true;
		boolean west = true;
		int tex_offset = 0;
		BlockType block;
		boolean adj_torch;
		short t;
		int xOff, zOff, blockOffset;
		int x, y, z;
		int textureId;
		byte data;
		int north_t, south_t, west_t, east_t, top_t, bottom_t;
		
		for(x=0; x<16; x++) {
			xOff = (x * 128 * 16);
			for(z=0; z<16; z++) {
				zOff = (z * 128);
				blockOffset = zOff + xOff-1;
				for(y=0; y<128; y++) {
					blockOffset++;
					adj_torch = false;

					// Grab our block type
					t = blockData.value[blockOffset];
					if(t < 1) {
						continue;
					}

					// Get the actual BlockType object
					block = blockArray[t];
					if (block == null)
					{
						//System.out.println("Unknown block ID: " + t);
						block = BLOCK_UNKNOWN;
					}

					// Check our texture sheet
					if (sheet != block.getTexSheet())
					{
						continue;
					}
					
					// Doublecheck for water
					if (!render_water && block.type == BLOCK_TYPE.WATER)
					{
						continue;
					}

					// Doublecheck for glass stuffs
					if ((pass == RENDER_PASS.GLASS && (block.type != BLOCK_TYPE.GLASS && block.type != BLOCK_TYPE.SOLID_PANE)) ||
							(pass != RENDER_PASS.SELECTED &&
							 pass != RENDER_PASS.GLASS && (block.type == BLOCK_TYPE.GLASS || block.type == BLOCK_TYPE.SOLID_PANE)))
					{
						continue;
					}
					
					// Grab our texture ID and verify it
					textureId = block.tex_idx;
					if(textureId == -1) {
						//System.out.println("Unknown block id: " + t);
						continue;
					}
					
					// Set up our intitial drawing parameters
					switch (pass)
					{
						case SOLIDS:
							if (!block.isSolid())
							{
								continue;
							}
							draw = false;
							above = true;
							below = true;
							north = true;
							south = true;
							east = true;
							west = true;

							// Check for adjacent blocks
							if (render_bedrock && t == BLOCK_BEDROCK.id)
							{
								// This block of code was more or less copied/modified directly from the "else" block
								// below - should see if there's a way we can abstract this instead.  Also, I suspect
								// that this is where we'd fix water rendering...
								
								// check above
								if(y<127 && blockData.value[blockOffset+1] != BLOCK_BEDROCK.id) {
									draw = true;
									above = false;
								}
								
								// check below
								if(y>0 && blockData.value[blockOffset-1] != BLOCK_BEDROCK.id) {
									draw = true;
									below = false;
								}
								
								// check north;
								if (this.getAdjNorthBlockId(x, y, z, blockOffset) != BLOCK_BEDROCK.id) {
									draw = true;
									north = false;
								}
							
								// check south
								if (this.getAdjSouthBlockId(x, y, z, blockOffset) != BLOCK_BEDROCK.id) {
									draw = true;
									south = false;
								}
								
								// check east
								if (this.getAdjEastBlockId(x, y, z, blockOffset) != BLOCK_BEDROCK.id) {
									draw = true;
									east = false;
								}
								
								// check west
								if (this.getAdjWestBlockId(x, y, z, blockOffset) != BLOCK_BEDROCK.id) {
									draw = true;
									west = false;
								}
							}
							else
							{
								// check above
								if(y<127 && checkSolid(blockData.value[blockOffset+1])) {
									draw = true;
									above = false;
								}
								
								// check below
								if(y>0 && checkSolid(blockData.value[blockOffset-1])) {
									draw = true;
									below = false;
								}
								
								// check north;
								if (checkSolid(this.getAdjNorthBlockId(x, y, z, blockOffset))) {
									draw = true;
									north = false;
								}
							
								// check south
								if (checkSolid(this.getAdjSouthBlockId(x, y, z, blockOffset))) {
									draw = true;
									south = false;
								}
								
								// check east
								if (checkSolid(this.getAdjEastBlockId(x, y, z, blockOffset))) {
									draw = true;
									east = false;
								}
								
								// check west
								if (checkSolid(this.getAdjWestBlockId(x, y, z, blockOffset))) {
									draw = true;
									west = false;
								}
							}
							break;

						case NONSTANDARD:
							if (block.isSolid())
							{
								continue;
							}
							draw = true;
							break;

						case GLASS:
							// If we got here, our checks above would have made sure that we're
							// only dealing with the proper materials.
							draw = true;
							break;

						case SELECTED:
							draw = false;
							for(int i=0;i<selectedMap.length;i++) {
								if(selectedMap[i] && level.HIGHLIGHT_ORES[i] == t) {
									// TODO: should maybe check our boundaries for similar ores, like we do for regular blocks
									draw = true;
									above = false;
									below = false;
									north = false;
									south = false;
									east = false;
									west = false;
									break;
								}
							}
							break;

						default:
							// Should never get here
							continue;
					}
					
					// Continue on to the actual rendering
					if (draw)
					{
						// Check to see if this block type has a texture ID which changes depending
						// on the block's data value
						if (block.texture_data_map != null)
						{
							data = getData(x, y, z);

							if (t == BLOCK_SAPLING.id)
							{
								// Special-case here for Sapling data, since we can't trust the upper two bits
								data &= 0x3;
							}
							else
							{
								// ... otherwise, just make sure we're dealing with the bottom four
								data &= 0xF;
							}

							// Now try to get the new texture
							try
							{
								textureId = block.texture_data_map.get(data);
							}
							catch (NullPointerException e)
							{
								// Just report and continue
								System.out.println("Unknown data value for block " + block.idStr + ": " + data);
							}
						}

						// If we're highlighting explored regions and there's an adjacent
						// torch, flip over to the "highlighted" textures
						if (highlight_explored)
						{
							adj_torch = hasAdjacentTorch(x,y,z);
							if (adj_torch)
							{
								textureId += 256;
								tex_offset = 256;
							}
							else
							{
								tex_offset = 0;
							}
						}
						else
						{
							tex_offset = 0;
						}

						// Now process the actual drawing
						switch(block.type)
						{
							case TORCH:
								renderTorch(textureId,x,y,z);
								break;
							case DECORATION_CROSS:
								renderCrossDecoration(textureId,x,y,z);
								break;
							case CROPS:
								renderCrops(textureId,x,y,z,block);
								break;
							case NETHER_WART:
								renderNetherWart(textureId,x,y,z,block);
								break;
							case LADDER:
								renderLadder(textureId,x,y,z);
								break;
							case FLOOR:
								renderFloor(textureId,x,y,z);
								break;
							case MINECART_TRACKS:
								renderMinecartTracks(textureId,x,y,z,block);
								break;
							case SIMPLE_RAIL:
								renderSimpleRail(textureId,x,y,z,block);
								break;
							case PRESSURE_PLATE:
								renderPlate(textureId,x,y,z);
								break;
							case DOOR:
								renderDoor(textureId,x,y,z,block);
								break;
							case STAIRS:
								renderStairs(textureId,x,y,z);
								break;
							case SIGNPOST:
								renderSignpost(textureId,x,y,z);
								break;
							case WALLSIGN:
								renderWallSign(textureId,x,y,z);
								break;
							case FENCE:
								renderFence(textureId,x,y,z,blockOffset,t);
								break;
							case FENCE_GATE:
								renderFenceGate(textureId,x,y,z,blockOffset);
								break;
							case LEVER:
								renderLever(textureId,x,y,z);
								break;
							case BUTTON:
								renderButton(textureId,x,y,z);
								break;
							case PORTAL:
								renderPortal(textureId,x,y,z,blockOffset,t);
								break;
							case THINSLICE:
								renderThinslice(textureId,x,y,z);
								break;
							case BED:
								renderBed(textureId,x,y,z,block);
								break;
							case TRAPDOOR:
								renderTrapdoor(textureId,x,y,z);
								break;
							case PISTON_BODY:
								renderPistonBody(textureId,x,y,z,block);
								break;
							case PISTON_HEAD:
								renderPistonHead(textureId,x,y,z,block,false,false);
								break;
							case CAKE:
								renderCake(textureId,x,y,z,block);
								break;
							case VINE:
								renderVine(textureId,x,y,z,blockOffset);
								break;
							case SOLID_PANE:
								renderSolidPane(textureId,x,y,z,blockOffset,t);
								break;
							case CHEST:
								renderChest(textureId,x,y,z,blockOffset,block);
								break;
							case HALFHEIGHT:
								renderHalfHeight(textureId,x,y,z,blockOffset);
								break;
							case SEMISOLID:
							case WATER:
							case GLASS:
								renderSemisolid(textureId,x,y,z,blockOffset,t);
								break;

							case NORMAL:
							case HUGE_MUSHROOM:
							default:
								north_t = textureId;
								south_t = textureId;
								west_t = textureId;
								east_t = textureId;
								top_t = textureId;
								bottom_t = textureId;

								// Huge Mushrooms are special-case since keeping the data in YAML seemed
								// like far too much work at the time. Keeping them there does technically
								// make more sense, so we should do that eventually.
								// TODO: That ^
								if (block.type == BLOCK_TYPE.HUGE_MUSHROOM)
								{
									int TEX_HUGE_MUSHROOM_PORES = block.texture_extra_map.get("pores");
									int TEX_HUGE_MUSHROOM_STEM = block.texture_extra_map.get("stem");
									data = getData(x, y, z);
									switch (data)
									{
										case 0:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											top_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
									    case 1:
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 2:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 3:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 4:
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 5:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 6:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 7:
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 8:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 9:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										case 10:
											north_t = TEX_HUGE_MUSHROOM_STEM + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_STEM + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_STEM + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_STEM + tex_offset;
											top_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
										default:
											north_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											south_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											west_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											east_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											top_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											bottom_t = TEX_HUGE_MUSHROOM_PORES + tex_offset;
											break;
									}
								}

								// Now assign the textures for each face, if we're supposed to
								if (block.texture_dir_map != null)
								{
									data = getData(x, y, z);
									BlockType.DIRECTION_ABS dir;
									if (block.texture_dir_data_map != null && block.texture_dir_data_map.containsKey(data))
									{
										dir = block.texture_dir_data_map.get(data);
									}
									else
									{
										dir = BlockType.DIRECTION_ABS.NORTH;
									}

									switch (dir)
									{
										case NORTH:
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.FORWARD))
											{
												north_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.FORWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.BACKWARD))
											{
												south_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.BACKWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.SIDES))
											{
												west_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
												east_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
											}
											break;
										case SOUTH:
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.BACKWARD))
											{
												north_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.BACKWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.FORWARD))
											{
												south_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.FORWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.SIDES))
											{
												west_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
												east_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
											}
											break;
										case WEST:
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.SIDES))
											{
												north_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
												south_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.FORWARD))
											{
												west_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.FORWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.BACKWARD))
											{
												east_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.BACKWARD) + tex_offset;
											}
											break;
										case EAST:
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.SIDES))
											{
												north_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
												south_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.SIDES) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.BACKWARD))
											{
												west_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.BACKWARD) + tex_offset;
											}
											if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.FORWARD))
											{
												east_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.FORWARD) + tex_offset;
											}
											break;
									}

									// Top/Bottom doesn't depend on orientation, at least for anything currently in Minecraft.
									// If Minecraft starts adding blocks that can be oriented Up or Down, we'll have to move
									// this back into the case statement above
									if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.TOP))
									{
										top_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.TOP) + tex_offset;
									}
									if (block.texture_dir_map.containsKey(BlockType.DIRECTION_REL.BOTTOM))
									{
										bottom_t = block.texture_dir_map.get(BlockType.DIRECTION_REL.BOTTOM) + tex_offset;
									}
								}

								// Finally, we're to the point of actually rendering the solid
								if(!east) this.renderWestEast(east_t, worldX+x, y, worldZ+z);
								if(!west) this.renderWestEast(west_t, worldX+x, y, worldZ+z+1);
								
								if(!below) this.renderTopDown(bottom_t, worldX+x, y, worldZ+z);
								if(!above) this.renderTopDown(top_t, worldX+x, y+1, worldZ+z);	
								
								if(!north) this.renderNorthSouth(north_t, worldX+x, y, worldZ+z);
								if(!south) this.renderNorthSouth(south_t, worldX+x+1, y, worldZ+z);
						}					
					}
				}
			}
		}
	}

	/**
	 * Returns whether or not this chunk contains paintings (to avoid unnecessary texture-swapping)
	 */
	public boolean hasPaintings()
	{
		return !this.paintings.isEmpty();
	}
	
	/**
	 * Renders paintings into our world.  Paintings are stored as Entities, not
	 * block-level data, so they have to be handled differently than everything else.
	 */
	public void renderPaintings()
	{
		PaintingInfo info;
		float start_x;
		float start_y;
		float start_z;
		float back_x;
		float back_z;
		float dX;
		float dZ;
		for (PaintingEntity painting : this.paintings)
		{
			info = MinecraftConstants.paintings.get(painting.name.toLowerCase());
			if (info == null)
			{
				System.out.println("Unknown painting name: " + painting.name);
				continue;
			}
			
			start_y = painting.tile_y + 0.5f + info.centery;
			switch (painting.dir)
			{
				case 0x0:
					// East
					start_x = painting.tile_x + 0.5f + info.centerx;
					start_z = painting.tile_z - 0.5f - TEX16;
					back_x = start_x;
					back_z = start_z + TEX32;
					dX = -1;
					dZ = 0;
					break;
				case 0x1:
					// North
					start_x = painting.tile_x - 0.5f - TEX16;
					start_z = painting.tile_z - 0.5f - info.centerx;
					back_x = start_x + TEX32;
					back_z = start_z;
					dX = 0;
					dZ = 1;
					break;
				case 0x2:
					// West
					start_x = painting.tile_x - 0.5f - info.centerx;
					start_z = painting.tile_z + 0.5f + TEX16;
					back_x = start_x;
					back_z = start_z - TEX32;
					dX = 1;
					dZ = 0;
					break;
				case 0x3:
				default:
					// South
					start_x = painting.tile_x + 0.5f + TEX16;
					start_z = painting.tile_z + 0.5f + info.centerx;
					back_x = start_x - TEX32;
					back_z = start_z;
					dX = 0;
					dZ = -1;
					break;
			}
			
			// Draw the painting face
			renderNonstandardVertical(info.offsetx, info.offsety, info.sizex_tex, info.sizey_tex,
					start_x, start_y, start_z,
					start_x + (dX*info.sizex), start_y-info.sizey, start_z + (dZ*info.sizex));
			
			PaintingInfo backinfo = MinecraftConstants.paintingback;

			// Back
			renderNonstandardVertical(backinfo.offsetx, backinfo.offsety, info.sizex_tex, info.sizey_tex,
					back_x, start_y, back_z,
					back_x + (dX*info.sizex), start_y-info.sizey, back_z + (dZ*info.sizex));
 
			// Sides
			renderNonstandardVertical(backinfo.offsetx, backinfo.offsety, info.sizex_tex, info.sizey_tex,
					start_x, start_y, start_z,
					back_x, start_y-info.sizey, back_z);
			renderNonstandardVertical(backinfo.offsetx, backinfo.offsety, info.sizex_tex, info.sizey_tex,
					start_x + (dX*info.sizex), start_y, start_z + (dZ*info.sizex),
					back_x + (dX*info.sizex), start_y-info.sizey, back_z + (dZ*info.sizex));
			
			// Top/Bottom
			renderNonstandardHorizontal(backinfo.offsetx, backinfo.offsety, info.sizex_tex, info.sizey_tex,
					start_x, start_z,
					back_x + (dX*info.sizex), back_z + (dZ*info.sizex),
					start_y-info.sizey
					);
			renderNonstandardHorizontal(backinfo.offsetx, backinfo.offsety, info.sizex_tex, info.sizey_tex,
					start_x, start_z,
					back_x + (dX*info.sizex), back_z + (dZ*info.sizex),
					start_y
					);
		}
	}
	
	public void renderSolid(int sheet, boolean render_bedrock, boolean render_water, boolean highlight_explored) {
		if (!this.usedTextureSheets.containsKey(sheet))
		{
			return;
		}
		if(isDirty.get(sheet)) {
				GL11.glNewList(this.displayListNums.get(sheet), GL11.GL_COMPILE);
				renderWorldSolids(sheet, render_bedrock, highlight_explored);
				GL11.glEndList();
				GL11.glNewList(this.nonstandardListNums.get(sheet), GL11.GL_COMPILE);
				//GL11.glDepthMask(false);
				renderWorldNonstandard(sheet, render_water, highlight_explored);
				//GL11.glDepthMask(true);
				GL11.glEndList();
				GL11.glNewList(this.glassListNums.get(sheet), GL11.GL_COMPILE);
				renderWorldGlass(sheet, highlight_explored);
				GL11.glEndList();
				this.isDirty.put(sheet, false);
		}
		GL11.glCallList(this.displayListNums.get(sheet));
	}
	
	public void renderNonstandard(int sheet) {
		if (!this.usedTextureSheets.containsKey(sheet))
		{
			return;
		}
		GL11.glCallList(this.nonstandardListNums.get(sheet));
	}

	public void renderGlass(int sheet) {
		if (!this.usedTextureSheets.containsKey(sheet))
		{
			return;
		}
		GL11.glCallList(this.glassListNums.get(sheet));
	}
	
	public void renderSelected(int sheet, boolean[] selectedMap) {
		if (!this.usedTextureSheets.containsKey(sheet))
		{
			return;
		}
		if(isSelectedDirty.get(sheet)) {
			GL11.glNewList(this.selectedDisplayListNums.get(sheet), GL11.GL_COMPILE);
			renderWorldSelected(sheet, selectedMap);
			GL11.glEndList();
			this.isSelectedDirty.put(sheet, false);
		}
		GL11.glCallList(this.selectedDisplayListNums.get(sheet));
	}
}