AE2 First Commit, the dawn of 1.7 hast arrived.

client/render/blocks/RenderBlockCharger.java

@@ -0,0 +1,156 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import appeng.api.util.IOrientable;
+import appeng.block.AEBaseBlock;
+import appeng.block.misc.BlockCharger;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+import appeng.tile.AEBaseTile;
+import appeng.util.Platform;
+
+public class RenderBlockCharger extends BaseBlockRender
+{
+
+	public RenderBlockCharger() {
+		super( true, 30 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		Tessellator tess = Tessellator.instance;
+
+		renderer.renderAllFaces = true;
+		setInvRenderBounds( renderer, 6, 1, 0, 10, 15, 2 );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		blk.getRendererInstance().setTemporaryRenderIcons( ExtraTextures.BlockChargerInside.getIcon(), null, null, null, null, null );
+
+		setInvRenderBounds( renderer, 2, 0, 2, 14, 3, 14 );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		setInvRenderBounds( renderer, 3, 3, 3, 13, 4, 13 );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		blk.getRendererInstance().setTemporaryRenderIcons( null, ExtraTextures.BlockChargerInside.getIcon(), null, null, null, null );
+
+		setInvRenderBounds( renderer, 2, 13, 2, 14, 16, 14 );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		setInvRenderBounds( renderer, 3, 12, 3, 13, 13, 13 );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		renderer.renderAllFaces = false;
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		preRenderInWorld( block, world, x, y, z, renderer );
+
+		BlockCharger blk = (BlockCharger) block;
+
+		IOrientable te = getOrientable( block, world, x, y, z );
+
+		ForgeDirection fdy = te.getUp();
+		ForgeDirection fdz = te.getForward();
+		ForgeDirection fdx = Platform.crossProduct( fdz, fdy ).getOpposite();
+
+		renderer.renderAllFaces = true;
+		renderBlockBounds( renderer, 6, 1, 0, 10, 15, 2, fdx, fdy, fdz );
+		boolean out = renderer.renderStandardBlock( blk, x, y, z );
+
+		blk.getRendererInstance().setTemporaryRenderIcons( ExtraTextures.BlockChargerInside.getIcon(), null, null, null, null, null );
+
+		renderBlockBounds( renderer, 2, 0, 2, 14, 3, 14, fdx, fdy, fdz );
+		out = renderer.renderStandardBlock( blk, x, y, z );
+
+		renderBlockBounds( renderer, 3, 3, 3, 13, 4, 13, fdx, fdy, fdz );
+		out = renderer.renderStandardBlock( blk, x, y, z );
+
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		blk.getRendererInstance().setTemporaryRenderIcons( null, ExtraTextures.BlockChargerInside.getIcon(), null, null, null, null );
+
+		renderBlockBounds( renderer, 2, 13, 2, 14, 16, 14, fdx, fdy, fdz );
+		out = renderer.renderStandardBlock( blk, x, y, z );
+
+		renderBlockBounds( renderer, 3, 12, 3, 13, 13, 13, fdx, fdy, fdz );
+		out = renderer.renderStandardBlock( blk, x, y, z );
+
+		renderer.renderAllFaces = false;
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		postRenderInWorld( renderer );
+		return out;
+	}
+
+	@Override
+	public void renderTile(AEBaseBlock block, AEBaseTile tile, Tessellator tess, double x, double y, double z, float f, RenderBlocks renderer)
+	{
+		ItemStack sis = null;
+		if ( tile instanceof IInventory )
+			sis = ((IInventory) tile).getStackInSlot( 0 );
+
+		if ( sis != null )
+		{
+			applyTESRRotation( x, y, z, tile.getForward(), tile.getUp() );
+
+			GL11.glPushMatrix();
+
+			try
+			{
+				GL11.glTranslatef( 0.5f, 0.45f, 0.5f );
+				GL11.glScalef( 1.0f / 1.1f, 1.0f / 1.1f, 1.0f / 1.1f );
+				GL11.glScalef( 1.0f, 1.0f, 1.0f );
+
+				int k = sis.itemID;
+				if ( sis.getItemSpriteNumber() == 0 && block != null && RenderBlocks.renderItemIn3d( Block.blocksList[k].getRenderType() ) )
+				{
+					GL11.glRotatef( 25.0f, 1.0f, 0.0f, 0.0f );
+					GL11.glRotatef( 15.0f, 0.0f, 1.0f, 0.0f );
+					GL11.glRotatef( 30.0f, 0.0f, 1.0f, 0.0f );
+				}
+
+				int light = tile.worldObj.getLightBrightnessForSkyBlocks( tile.xCoord, tile.yCoord, tile.zCoord, 0 );
+				int br = light;// << 20 | light << 4;
+				int var11 = br % 65536;
+				int var12 = br / 65536;
+				OpenGlHelper.setLightmapTextureCoords( OpenGlHelper.lightmapTexUnit, var11, var12 );
+
+				GL11.glColor4f( 1.0F, 1.0F, 1.0F, 1.0F );
+
+				GL11.glDisable( GL11.GL_LIGHTING );
+				GL11.glDisable( GL12.GL_RESCALE_NORMAL );
+				tess.setColorOpaque_F( 1.0f, 1.0f, 1.0f );
+
+				doRenderItem( sis, tile );
+			}
+			catch (Exception err)
+			{
+				err.printStackTrace();
+			}
+
+			GL11.glPopMatrix();
+		}
+	}
+
+}

client/render/blocks/RenderBlockController.java

@@ -0,0 +1,125 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.world.IBlockAccess;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+import appeng.tile.networking.TileController;
+
+public class RenderBlockController extends BaseBlockRender
+{
+
+	public RenderBlockController() {
+		super( false, 20 );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock blk, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+
+		boolean xx = world.getBlockTileEntity( x - 1, y, z ) instanceof TileController && world.getBlockTileEntity( x + 1, y, z ) instanceof TileController;
+		boolean yy = world.getBlockTileEntity( x, y - 1, z ) instanceof TileController && world.getBlockTileEntity( x, y + 1, z ) instanceof TileController;
+		boolean zz = world.getBlockTileEntity( x, y, z - 1 ) instanceof TileController && world.getBlockTileEntity( x, y, z + 1 ) instanceof TileController;
+
+		int meta = world.getBlockMetadata( x, y, z );
+		boolean hasPower = meta > 0;
+		boolean isConflict = meta == 2;
+
+		ExtraTextures lights = null;
+
+		if ( xx && !yy && !zz )
+		{
+			if ( hasPower )
+			{
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumnPowered.getIcon() );
+				if ( isConflict )
+					lights = ExtraTextures.BlockControllerColumnConflict;
+				else
+					lights = ExtraTextures.BlockControllerColumnLights;
+			}
+			else
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumn.getIcon() );
+
+			renderer.uvRotateEast = 1;
+			renderer.uvRotateWest = 1;
+			renderer.uvRotateTop = 1;
+			renderer.uvRotateBottom = 1;
+		}
+		else if ( !xx && yy && !zz )
+		{
+			if ( hasPower )
+			{
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumnPowered.getIcon() );
+				if ( isConflict )
+					lights = ExtraTextures.BlockControllerColumnConflict;
+				else
+					lights = ExtraTextures.BlockControllerColumnLights;
+			}
+			else
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumn.getIcon() );
+
+			renderer.uvRotateEast = 0;
+			renderer.uvRotateNorth = 0;
+		}
+		else if ( !xx && !yy && zz )
+		{
+			if ( hasPower )
+			{
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumnPowered.getIcon() );
+				if ( isConflict )
+					lights = ExtraTextures.BlockControllerColumnConflict;
+				else
+					lights = ExtraTextures.BlockControllerColumnLights;
+			}
+			else
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerColumn.getIcon() );
+
+			renderer.uvRotateNorth = 1;
+			renderer.uvRotateSouth = 1;
+			renderer.uvRotateTop = 0;
+		}
+		else if ( (xx ? 1 : 0) + (yy ? 1 : 0) + (zz ? 1 : 0) >= 2 )
+		{
+			int v = (Math.abs( x ) + Math.abs( y ) + Math.abs( z )) % 2;
+			renderer.uvRotateEast = renderer.uvRotateBottom = renderer.uvRotateNorth = renderer.uvRotateSouth = renderer.uvRotateTop = renderer.uvRotateWest = 0;
+
+			if ( v == 0 )
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerInsideA.getIcon() );
+			else
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerInsideB.getIcon() );
+		}
+		else
+		{
+			if ( hasPower )
+			{
+				blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.BlockControllerPowered.getIcon() );
+				if ( isConflict )
+					lights = ExtraTextures.BlockControllerConflict;
+				else
+					lights = ExtraTextures.BlockControllerLights;
+			}
+			else
+				blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		}
+
+		boolean out = renderer.renderStandardBlock( blk, x, y, z );
+		if ( lights != null )
+		{
+			Tessellator.instance.setColorOpaque_F( 1.0f, 1.0f, 1.0f );
+			Tessellator.instance.setBrightness( 14 << 20 | 14 << 4 );
+			renderer.renderFaceXNeg( blk, x, y, z, lights.getIcon() );
+			renderer.renderFaceXPos( blk, x, y, z, lights.getIcon() );
+			renderer.renderFaceYNeg( blk, x, y, z, lights.getIcon() );
+			renderer.renderFaceYPos( blk, x, y, z, lights.getIcon() );
+			renderer.renderFaceZNeg( blk, x, y, z, lights.getIcon() );
+			renderer.renderFaceZPos( blk, x, y, z, lights.getIcon() );
+		}
+
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+		renderer.uvRotateEast = renderer.uvRotateBottom = renderer.uvRotateNorth = renderer.uvRotateSouth = renderer.uvRotateTop = renderer.uvRotateWest = 0;
+		return out;
+	}
+}

client/render/blocks/RenderBlockCrank.java

@@ -0,0 +1,87 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.tile.AEBaseTile;
+import appeng.tile.grindstone.TileCrank;
+
+public class RenderBlockCrank extends BaseBlockRender
+{
+
+	public RenderBlockCrank() {
+		super( true, 60 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.renderAllFaces = true;
+
+		renderer.setRenderBounds( 0.5D - 0.05, 0.5D - 0.5, 0.5D - 0.05, 0.5D + 0.05, 0.5D + 0.3, 0.5D + 0.05 );
+		super.renderInventory( blk, is, renderer );
+
+		renderer.setRenderBounds( 0.70D - 0.15, 0.75D - 0.05, 0.5D - 0.05, 0.70D + 0.28, 0.75D + 0.05, 0.5D + 0.05 );
+		super.renderInventory( blk, is, renderer );
+
+		renderer.renderAllFaces = false;
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		return true;
+	}
+
+	@Override
+	public void renderTile(AEBaseBlock blk, AEBaseTile tile, Tessellator tess, double x, double y, double z, float f, RenderBlocks rbinstance)
+	{
+		TileCrank tc = (TileCrank) tile;
+		if ( tc.getUp() == null || tc.getUp() == ForgeDirection.UNKNOWN )
+			return;
+
+		Minecraft.getMinecraft().getTextureManager().bindTexture( TextureMap.locationBlocksTexture );
+		RenderHelper.disableStandardItemLighting();
+
+		if ( Minecraft.isAmbientOcclusionEnabled() )
+			GL11.glShadeModel( GL11.GL_SMOOTH );
+		else
+			GL11.glShadeModel( GL11.GL_FLAT );
+
+		GL11.glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
+
+		applyTESRRotation( x, y, z, tile.getForward(), tile.getUp() );
+
+		GL11.glTranslated( 0.5, 0, 0.5 );
+		GL11.glRotatef( tc.visibleRotation, 0, 1, 0 );
+		GL11.glTranslated( -0.5, 0, -0.5 );
+
+		tess.setTranslation( -tc.xCoord, -tc.yCoord, -tc.zCoord );
+		tess.startDrawingQuads();
+		rbinstance.renderAllFaces = true;
+		rbinstance.blockAccess = tc.worldObj;
+
+		rbinstance.setRenderBounds( 0.5D - 0.05, 0.5D - 0.5, 0.5D - 0.05, 0.5D + 0.05, 0.5D + 0.1, 0.5D + 0.05 );
+
+		rbinstance.renderStandardBlock( blk, tc.xCoord, tc.yCoord, tc.zCoord );
+
+		rbinstance.setRenderBounds( 0.70D - 0.15, 0.55D - 0.05, 0.5D - 0.05, 0.70D + 0.15, 0.55D + 0.05, 0.5D + 0.05 );
+
+		rbinstance.renderStandardBlock( blk, tc.xCoord, tc.yCoord, tc.zCoord );
+
+		tess.draw();
+		tess.setTranslation( 0, 0, 0 );
+		RenderHelper.enableStandardItemLighting();
+	}
+
+}

client/render/blocks/RenderBlockEnergyCube.java

@@ -0,0 +1,47 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import appeng.api.implementations.IAEItemPowerStorage;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+
+public class RenderBlockEnergyCube extends BaseBlockRender
+{
+
+	public RenderBlockEnergyCube() {
+		super( false, 20 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		IAEItemPowerStorage myItem = (IAEItemPowerStorage) is.getItem();
+		double internalCurrentPower = myItem.getAECurrentPower( is );
+		double internalMaxPower = myItem.getAEMaxPower( is );
+
+		int meta = (int) (8.0 * (internalCurrentPower / internalMaxPower));
+
+		if ( meta > 7 )
+			meta = 7;
+		if ( meta < 0 )
+			meta = 0;
+
+		renderer.setOverrideBlockTexture( blk.getIcon( 0, meta ) );
+		super.renderInventory( blk, is, renderer );
+		renderer.setOverrideBlockTexture( null );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock blk, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		int meta = world.getBlockMetadata( x, y, z );
+
+		renderer.overrideBlockTexture = blk.getIcon( 0, meta );
+		boolean out = renderer.renderStandardBlock( blk, x, y, z );
+		renderer.overrideBlockTexture = null;
+
+		return out;
+	}
+}

client/render/blocks/RenderBlockWireless.java

@@ -0,0 +1,247 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Icon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.AEColor;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.render.BlockRenderInfo;
+import appeng.client.texture.CableBusTextures;
+import appeng.client.texture.ExtraTextures;
+import appeng.client.texture.OffsetIcon;
+import appeng.tile.networking.TileWireless;
+import appeng.util.Platform;
+
+public class RenderBlockWireless extends BaseBlockRender
+{
+
+	public RenderBlockWireless() {
+		super( false, 20 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		this.blk = blk;
+		cenx = 0;
+		ceny = 0;
+		cenz = 0;
+		hasChan = false;
+		hasPower = false;
+		BlockRenderInfo ri = blk.getRendererInstance();
+		Tessellator tess = Tessellator.instance;
+
+		renderer.renderAllFaces = true;
+
+		Icon r = CableBusTextures.PartMonitorSidesStatus.getIcon();
+		ri.setTemporaryRenderIcons( r, r, CableBusTextures.PartMonitorSides.getIcon(), CableBusTextures.PartMonitorSides.getIcon(), r, r );
+		renderBlockBounds( renderer, 5, 5, 0, 11, 11, 1, ForgeDirection.EAST, ForgeDirection.UP, ForgeDirection.SOUTH );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		r = CableBusTextures.PartMonitorSides.getIcon();
+		ri.setTemporaryRenderIcons( r, r, ExtraTextures.BlockChargerInside.getIcon(), ExtraTextures.BlockChargerInside.getIcon(), r, r );
+		renderBlockBounds( renderer, 5, 5, 1, 11, 11, 2, ForgeDirection.EAST, ForgeDirection.UP, ForgeDirection.SOUTH );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		tess.startDrawingQuads();
+		ri.setTemporaryRenderIcon( null );
+		renderTorchAtAngle( renderer, ForgeDirection.EAST, ForgeDirection.UP, ForgeDirection.SOUTH );
+		super.postRenderInWorld( renderer );
+		tess.draw();
+
+		ri.setTemporaryRenderIcons( r, r, ExtraTextures.BlockChargerInside.getIcon(), ExtraTextures.BlockChargerInside.getIcon(), r, r );
+
+		ForgeDirection sides[] = new ForgeDirection[] { ForgeDirection.EAST, ForgeDirection.WEST, ForgeDirection.UP, ForgeDirection.DOWN };
+
+		int s = 1;
+
+		for (ForgeDirection side : sides)
+		{
+			renderBlockBounds( renderer, 8 + (side.offsetX != 0 ? side.offsetX * 2 : -2), 8 + (side.offsetY != 0 ? side.offsetY * 2 : -2), 2
+					+ (side.offsetZ != 0 ? side.offsetZ * 2 : -1) + s, 8 + (side.offsetX != 0 ? side.offsetX * 4 : 2),
+					8 + (side.offsetY != 0 ? side.offsetY * 4 : 2), 2 + (side.offsetZ != 0 ? side.offsetZ * 5 : 1) + s, ForgeDirection.EAST, ForgeDirection.UP,
+					ForgeDirection.SOUTH );
+			renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+		}
+
+		s = 3;
+		for (ForgeDirection side : sides)
+		{
+			renderBlockBounds( renderer, 8 + (side.offsetX != 0 ? side.offsetX * 4 : -1), 8 + (side.offsetY != 0 ? side.offsetY * 4 : -1), 1
+					+ (side.offsetZ != 0 ? side.offsetZ * 4 : -1) + s, 8 + (side.offsetX != 0 ? side.offsetX * 5 : 1),
+					8 + (side.offsetY != 0 ? side.offsetY * 5 : 1), 2 + (side.offsetZ != 0 ? side.offsetZ * 5 : 1) + s, ForgeDirection.EAST, ForgeDirection.UP,
+					ForgeDirection.SOUTH );
+
+			renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+		}
+	}
+
+	int cenx = 0;
+	int ceny = 0;
+	int cenz = 0;
+	AEBaseBlock blk;
+	boolean hasChan = false;
+	boolean hasPower = false;
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock blk, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		TileWireless tw = blk.getTileEntity( world, x, y, z );
+		this.blk = blk;
+		if ( tw != null )
+		{
+			hasChan = (tw.clientFlags & (TileWireless.POWERED_FLAG | TileWireless.CHANNEL_FLAG)) == (TileWireless.POWERED_FLAG | TileWireless.CHANNEL_FLAG);
+			hasPower = (tw.clientFlags & TileWireless.POWERED_FLAG) == TileWireless.POWERED_FLAG;
+
+			BlockRenderInfo ri = blk.getRendererInstance();
+
+			ForgeDirection fdy = tw.getUp();
+			ForgeDirection fdz = tw.getForward();
+			ForgeDirection fdx = Platform.crossProduct( fdz, fdy ).getOpposite();
+
+			renderer.renderAllFaces = true;
+
+			Icon r = CableBusTextures.PartMonitorSidesStatus.getIcon();
+			ri.setTemporaryRenderIcons( r, r, CableBusTextures.PartMonitorSides.getIcon(), CableBusTextures.PartMonitorSides.getIcon(), r, r );
+			renderBlockBounds( renderer, 5, 5, 0, 11, 11, 1, fdx, fdy, fdz );
+			super.renderInWorld( blk, world, x, y, z, renderer );
+
+			r = CableBusTextures.PartMonitorSides.getIcon();
+			ri.setTemporaryRenderIcons( r, r, ExtraTextures.BlockChargerInside.getIcon(), ExtraTextures.BlockChargerInside.getIcon(), r, r );
+			renderBlockBounds( renderer, 5, 5, 1, 11, 11, 2, fdx, fdy, fdz );
+			super.renderInWorld( blk, world, x, y, z, renderer );
+
+			cenx = x;
+			ceny = y;
+			cenz = z;
+			ri.setTemporaryRenderIcon( null );
+
+			renderTorchAtAngle( renderer, fdx, fdy, fdz );
+			super.postRenderInWorld( renderer );
+
+			ri.setTemporaryRenderIcons( r, r, ExtraTextures.BlockChargerInside.getIcon(), ExtraTextures.BlockChargerInside.getIcon(), r, r );
+
+			ForgeDirection sides[] = new ForgeDirection[] { ForgeDirection.EAST, ForgeDirection.WEST, ForgeDirection.UP, ForgeDirection.DOWN };
+
+			int s = 1;
+
+			for (ForgeDirection side : sides)
+			{
+				renderBlockBounds( renderer, 8 + (side.offsetX != 0 ? side.offsetX * 2 : -2), 8 + (side.offsetY != 0 ? side.offsetY * 2 : -2), 2
+						+ (side.offsetZ != 0 ? side.offsetZ * 2 : -1) + s, 8 + (side.offsetX != 0 ? side.offsetX * 4 : 2),
+						8 + (side.offsetY != 0 ? side.offsetY * 4 : 2), 2 + (side.offsetZ != 0 ? side.offsetZ * 5 : 1) + s, fdx, fdy, fdz );
+				super.renderInWorld( blk, world, x, y, z, renderer );
+			}
+
+			s = 3;
+			for (ForgeDirection side : sides)
+			{
+				renderBlockBounds( renderer, 8 + (side.offsetX != 0 ? side.offsetX * 4 : -1), 8 + (side.offsetY != 0 ? side.offsetY * 4 : -1), 1
+						+ (side.offsetZ != 0 ? side.offsetZ * 4 : -1) + s, 8 + (side.offsetX != 0 ? side.offsetX * 5 : 1),
+						8 + (side.offsetY != 0 ? side.offsetY * 5 : 1), 2 + (side.offsetZ != 0 ? side.offsetZ * 5 : 1) + s, fdx, fdy, fdz );
+				super.renderInWorld( blk, world, x, y, z, renderer );
+			}
+
+			r = CableBusTextures.PartMonitorSidesStatusLights.getIcon();
+			// ri.setTemporaryRenderIcons( r, r, ExtraTextures.BlockChargerInside.getIcon(),
+			// ExtraTextures.BlockChargerInside.getIcon(), r, r );
+			renderBlockBounds( renderer, 5, 5, 0, 11, 11, 1, fdx, fdy, fdz );
+
+			if ( hasChan )
+			{
+				int l = 14;
+				Tessellator.instance.setBrightness( l << 20 | l << 4 );
+				Tessellator.instance.setColorOpaque_I( AEColor.Transparent.blackVariant );
+			}
+			else if ( hasPower )
+			{
+				int l = 9;
+				Tessellator.instance.setBrightness( l << 20 | l << 4 );
+				Tessellator.instance.setColorOpaque_I( AEColor.Transparent.whiteVariant );
+			}
+			else
+			{
+				Tessellator.instance.setBrightness( 0 );
+				Tessellator.instance.setColorOpaque_I( 0x000000 );
+			}
+
+			if ( ForgeDirection.UP != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.UP );
+			if ( ForgeDirection.DOWN != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.DOWN );
+			if ( ForgeDirection.EAST != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.EAST );
+			if ( ForgeDirection.WEST != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.WEST );
+			if ( ForgeDirection.SOUTH != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.SOUTH );
+			if ( ForgeDirection.NORTH != fdz.getOpposite() )
+				super.renderFace( x, y, z, blk, r, renderer, ForgeDirection.NORTH );
+
+			ri.setTemporaryRenderIcon( null );
+			renderer.renderAllFaces = false;
+		}
+
+		return true;
+	}
+
+	private void renderTorchAtAngle(RenderBlocks renderer, ForgeDirection x, ForgeDirection y, ForgeDirection z)
+	{
+		Icon r = (hasChan ? CableBusTextures.BlockWirelessOn.getIcon() : blk.getIcon( 0, 0 ));
+		Icon sides = new OffsetIcon( r, 0.0f, -2.0f );
+
+		switch (z)
+		{
+		case DOWN:
+			renderer.uvRotateNorth = 3;
+			renderer.uvRotateSouth = 3;
+			renderer.uvRotateEast = 3;
+			renderer.uvRotateWest = 3;
+			break;
+		case EAST:
+			renderer.uvRotateTop = 1;
+			renderer.uvRotateBottom = 2;
+			renderer.uvRotateEast = 2;
+			renderer.uvRotateWest = 1;
+			break;
+		case NORTH:
+			renderer.uvRotateTop = 0;
+			renderer.uvRotateBottom = 0;
+			renderer.uvRotateNorth = 2;
+			renderer.uvRotateSouth = 1;
+			break;
+		case SOUTH:
+			renderer.uvRotateTop = 3;
+			renderer.uvRotateBottom = 3;
+			renderer.uvRotateNorth = 1;
+			renderer.uvRotateSouth = 2;
+			break;
+		case WEST:
+			renderer.uvRotateTop = 2;
+			renderer.uvRotateBottom = 1;
+			renderer.uvRotateEast = 1;
+			renderer.uvRotateWest = 2;
+			break;
+		default:
+			break;
+		}
+
+		Tessellator.instance.setColorOpaque_I( 0xffffff );
+		renderBlockBounds( renderer, 0, 7, 1, 16, 9, 16, x, y, z );
+		renderFace( cenx, ceny, cenz, blk, sides, renderer, y );
+		renderFace( cenx, ceny, cenz, blk, sides, renderer, y.getOpposite() );
+
+		renderBlockBounds( renderer, 7, 0, 1, 9, 16, 16, x, y, z );
+		renderFace( cenx, ceny, cenz, blk, sides, renderer, x );
+		renderFace( cenx, ceny, cenz, blk, sides, renderer, x.getOpposite() );
+
+		renderBlockBounds( renderer, 7, 7, 1, 9, 9, 10.6, x, y, z );
+		renderFace( cenx, ceny, cenz, blk, r, renderer, z );
+	}
+}

client/render/blocks/RenderCable.java

@@ -0,0 +1,62 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.util.Icon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+
+public class RenderCable extends BaseBlockRender
+{
+
+	public void renderCableAt(double Thickness, IBlockAccess world, int x, int y, int z, AEBaseBlock block, RenderBlocks renderer, Icon texture, double pull,
+			EnumSet<ForgeDirection> connections)
+	{
+
+		if ( connections.contains( ForgeDirection.UNKNOWN ) )
+		{
+			renderer.setRenderBounds( 0.5D - Thickness, 0.5D - Thickness, 0.5D - Thickness, 0.5D + Thickness, 0.5D + Thickness, 0.5D + Thickness );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.WEST ) )
+		{
+			renderer.setRenderBounds( 0.0D, 0.5D - Thickness, 0.5D - Thickness, 0.5D - Thickness - pull, 0.5D + Thickness, 0.5D + Thickness );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.EAST ) )
+		{
+			renderer.setRenderBounds( 0.5D + Thickness + pull, 0.5D - Thickness, 0.5D - Thickness, 1.0D, 0.5D + Thickness, 0.5D + Thickness );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.NORTH ) )
+		{
+			renderer.setRenderBounds( 0.5D - Thickness, 0.5D - Thickness, 0.0D, 0.5D + Thickness, 0.5D + Thickness, 0.5D - Thickness - pull );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.SOUTH ) )
+		{
+			renderer.setRenderBounds( 0.5D - Thickness, 0.5D - Thickness, 0.5D + Thickness + pull, 0.5D + Thickness, 0.5D + Thickness, 1.0D );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.DOWN ) )
+		{
+			renderer.setRenderBounds( 0.5D - Thickness, 0.0D, 0.5D - Thickness, 0.5D + Thickness, 0.5D - Thickness - pull, 0.5D + Thickness );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+		if ( connections.contains( ForgeDirection.UP ) )
+		{
+			renderer.setRenderBounds( 0.5D - Thickness, 0.5D + Thickness + pull, 0.5D - Thickness, 0.5D + Thickness, 1.0D, 0.5D + Thickness );
+			renderer.renderStandardBlock( block, x, y, z );
+		}
+
+	}
+}

client/render/blocks/RenderDrive.java

@@ -0,0 +1,308 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Icon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+import appeng.tile.storage.TileDrive;
+import appeng.util.Platform;
+
+public class RenderDrive extends BaseBlockRender
+{
+
+	public RenderDrive() {
+		super( false, 0 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.overrideBlockTexture = ExtraTextures.getMissing();
+		this.renderInvBlock( EnumSet.of( ForgeDirection.SOUTH ), block, Tessellator.instance, 0x000000, renderer );
+
+		renderer.overrideBlockTexture = null;
+		super.renderInventory( block, is, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		TileDrive sp = imb.getTileEntity( world, x, y, z );
+		renderer.setRenderBounds( 0, 0, 0, 1, 1, 1 );
+
+		ForgeDirection up = sp.getUp();
+		ForgeDirection forward = sp.getForward();
+		ForgeDirection west = Platform.crossProduct( forward, up );
+
+		boolean result = super.renderInWorld( imb, world, x, y, z, renderer );
+		Tessellator tess = Tessellator.instance;
+
+		Icon ico = ExtraTextures.MEStorageCellTextures.getIcon();
+
+		int b = world.getLightBrightnessForSkyBlocks( x + forward.offsetX, y + forward.offsetY, z + forward.offsetZ, 0 );
+
+		for (int yy = 0; yy < 5; yy++)
+		{
+			for (int xx = 0; xx < 2; xx++)
+			{
+				int stat = sp.getCellStatus( yy * 2 + (1 - xx) );
+				selectFace( renderer, west, up, forward, 2 + xx * 7, 7 + xx * 7, 1 + yy * 3, 3 + yy * 3 );
+
+				int spin = 0;
+
+				switch (forward.offsetX + forward.offsetY * 2 + forward.offsetZ * 3)
+				{
+				case 1:
+					switch (up)
+					{
+					case UP:
+						spin = 3;
+						break;
+					case DOWN:
+						spin = 1;
+						break;
+					case NORTH:
+						spin = 0;
+						break;
+					case SOUTH:
+						spin = 2;
+						break;
+					default:
+					}
+					break;
+				case -1:
+					switch (up)
+					{
+					case UP:
+						spin = 1;
+						break;
+					case DOWN:
+						spin = 3;
+						break;
+					case NORTH:
+						spin = 0;
+						break;
+					case SOUTH:
+						spin = 2;
+						break;
+					default:
+					}
+					break;
+				case -2:
+					switch (up)
+					{
+					case EAST:
+						spin = 1;
+						break;
+					case WEST:
+						spin = 3;
+						break;
+					case NORTH:
+						spin = 2;
+						break;
+					case SOUTH:
+						spin = 0;
+						break;
+					default:
+					}
+					break;
+				case 2:
+					switch (up)
+					{
+					case EAST:
+						spin = 1;
+						break;
+					case WEST:
+						spin = 3;
+						break;
+					case NORTH:
+						spin = 0;
+						break;
+					case SOUTH:
+						spin = 0;
+						break;
+					default:
+					}
+					break;
+				case 3:
+					switch (up)
+					{
+					case UP:
+						spin = 2;
+						break;
+					case DOWN:
+						spin = 0;
+						break;
+					case EAST:
+						spin = 3;
+						break;
+					case WEST:
+						spin = 1;
+						break;
+					default:
+					}
+					break;
+				case -3:
+					switch (up)
+					{
+					case UP:
+						spin = 2;
+						break;
+					case DOWN:
+						spin = 0;
+						break;
+					case EAST:
+						spin = 1;
+						break;
+					case WEST:
+						spin = 3;
+						break;
+					default:
+					}
+					break;
+				}
+
+				double u1 = ico.getInterpolatedU( (spin % 4 < 2) ? 1 : 6 );
+				double u2 = ico.getInterpolatedU( ((spin + 1) % 4 < 2) ? 1 : 6 );
+				double u3 = ico.getInterpolatedU( ((spin + 2) % 4 < 2) ? 1 : 6 );
+				double u4 = ico.getInterpolatedU( ((spin + 3) % 4 < 2) ? 1 : 6 );
+
+				int m = 1;
+				int mx = 3;
+				if ( stat == 0 )
+				{
+					m = 4;
+					mx = 5;
+				}
+
+				double v1 = ico.getInterpolatedV( ((spin + 1) % 4 < 2) ? m : mx );
+				double v2 = ico.getInterpolatedV( ((spin + 2) % 4 < 2) ? m : mx );
+				double v3 = ico.getInterpolatedV( ((spin + 3) % 4 < 2) ? m : mx );
+				double v4 = ico.getInterpolatedV( ((spin + 0) % 4 < 2) ? m : mx );
+
+				tess.setBrightness( b );
+				tess.setColorOpaque_I( 0xffffff );
+				switch (forward.offsetX + forward.offsetY * 2 + forward.offsetZ * 3)
+				{
+				case 1:
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMinZ, u4, v4 );
+					break;
+				case -1:
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMinZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+					break;
+				case -2:
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+					break;
+				case 2:
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+					break;
+				case 3:
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMinY, z + renderer.renderMaxZ, u4, v4 );
+					break;
+				case -3:
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMinY, z + renderer.renderMaxZ, u1, v1 );
+					tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+					tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u4, v4 );
+					break;
+				}
+
+				if ( (forward == ForgeDirection.UP && up == ForgeDirection.SOUTH) || forward == ForgeDirection.DOWN )
+					selectFace( renderer, west, up, forward, 3 + xx * 7, 4 + xx * 7, 1 + yy * 3, 2 + yy * 3 );
+				else
+					selectFace( renderer, west, up, forward, 5 + xx * 7, 6 + xx * 7, 2 + yy * 3, 3 + yy * 3 );
+
+				if ( stat != 0 )
+				{
+					Icon wico = ExtraTextures.White.getIcon();
+					u1 = wico.getInterpolatedU( (spin % 4 < 2) ? 1 : 6 );
+					u2 = wico.getInterpolatedU( ((spin + 1) % 4 < 2) ? 1 : 6 );
+					u3 = wico.getInterpolatedU( ((spin + 2) % 4 < 2) ? 1 : 6 );
+					u4 = wico.getInterpolatedU( ((spin + 3) % 4 < 2) ? 1 : 6 );
+
+					v1 = wico.getInterpolatedV( ((spin + 1) % 4 < 2) ? 1 : 3 );
+					v2 = wico.getInterpolatedV( ((spin + 2) % 4 < 2) ? 1 : 3 );
+					v3 = wico.getInterpolatedV( ((spin + 3) % 4 < 2) ? 1 : 3 );
+					v4 = wico.getInterpolatedV( ((spin + 0) % 4 < 2) ? 1 : 3 );
+
+					if ( sp.isPowered() )
+						tess.setBrightness( 15 << 20 | 15 << 4 );
+					else
+						tess.setBrightness( 0 );
+
+					if ( stat == 1 )
+						Tessellator.instance.setColorOpaque_I( 0x00ff00 );
+					if ( stat == 2 )
+						Tessellator.instance.setColorOpaque_I( 0xffaa00 );
+					if ( stat == 3 )
+						Tessellator.instance.setColorOpaque_I( 0xff0000 );
+
+					switch (forward.offsetX + forward.offsetY * 2 + forward.offsetZ * 3)
+					{
+					case 1:
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMinZ, u4, v4 );
+						break;
+					case -1:
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMinZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+						break;
+					case -2:
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+						break;
+					case 2:
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMinZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMinZ, u4, v4 );
+						break;
+					case 3:
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMinY, z + renderer.renderMaxZ, u4, v4 );
+						break;
+					case -3:
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMinY, z + renderer.renderMaxZ, u1, v1 );
+						tess.addVertexWithUV( x + renderer.renderMinX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u2, v2 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMaxY, z + renderer.renderMaxZ, u3, v3 );
+						tess.addVertexWithUV( x + renderer.renderMaxX, y + renderer.renderMinY, z + renderer.renderMaxZ, u4, v4 );
+						break;
+					}
+				}
+			}
+		}
+
+		renderer.overrideBlockTexture = null;
+		return result;
+	}
+}

client/render/blocks/RenderMEChest.java

@@ -0,0 +1,119 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Icon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.storage.ICellHandler;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+import appeng.client.texture.FlipableIcon;
+import appeng.client.texture.OffsetIcon;
+import appeng.tile.storage.TileChest;
+import appeng.util.Platform;
+
+public class RenderMEChest extends BaseBlockRender
+{
+
+	public RenderMEChest() {
+		super( false, 0 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.overrideBlockTexture = ExtraTextures.getMissing();
+		this.renderInvBlock( EnumSet.of( ForgeDirection.SOUTH ), block, Tessellator.instance, 0x000000, renderer );
+
+		renderer.overrideBlockTexture = ExtraTextures.MEChest.getIcon();
+		this.renderInvBlock( EnumSet.of( ForgeDirection.UP ), block, Tessellator.instance, 0xffffff, renderer );
+
+		renderer.overrideBlockTexture = null;
+		super.renderInventory( block, is, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		TileChest sp = imb.getTileEntity( world, x, y, z );
+		renderer.setRenderBounds( 0, 0, 0, 1, 1, 1 );
+
+		ForgeDirection up = sp.getUp();
+		ForgeDirection forward = sp.getForward();
+		ForgeDirection west = Platform.crossProduct( forward, up );
+
+		preRenderInWorld( imb, world, x, y, z, renderer );
+
+		int stat = sp.getCellStatus( 0 );
+		boolean result = renderer.renderStandardBlock( imb, x, y, z );
+
+		selectFace( renderer, west, up, forward, 5, 16 - 5, 9, 12 );
+
+		int offsetU = -4;
+		int offsetV = 8;
+		if ( stat == 0 )
+			offsetV = 3;
+
+		int b = world.getLightBrightnessForSkyBlocks( x + forward.offsetX, y + forward.offsetY, z + forward.offsetZ, 0 );
+		Tessellator.instance.setBrightness( b );
+		Tessellator.instance.setColorOpaque_I( 0xffffff );
+
+		FlipableIcon fico = new FlipableIcon( new OffsetIcon( ExtraTextures.MEStorageCellTextures.getIcon(), offsetU, offsetV ) );
+		if ( forward == ForgeDirection.EAST && (up == ForgeDirection.NORTH || up == ForgeDirection.SOUTH) )
+			fico.setFlip( true, false );
+		else if ( forward == ForgeDirection.NORTH && up == ForgeDirection.EAST )
+			fico.setFlip( false, true );
+		else if ( forward == ForgeDirection.NORTH && up == ForgeDirection.WEST )
+			fico.setFlip( true, false );
+		else if ( forward == ForgeDirection.DOWN && up == ForgeDirection.EAST )
+			fico.setFlip( false, true );
+		else if ( forward == ForgeDirection.DOWN )
+			fico.setFlip( true, false );
+
+		renderFace( x, y, z, imb, fico, renderer, forward );
+
+		if ( stat != 0 )
+		{
+			b = 0;
+			if ( sp.isPowered() )
+			{
+				b = 15 << 20 | 15 << 4;
+			}
+
+			Tessellator.instance.setBrightness( b );
+			if ( stat == 1 )
+				Tessellator.instance.setColorOpaque_I( 0x00ff00 );
+			if ( stat == 2 )
+				Tessellator.instance.setColorOpaque_I( 0xffaa00 );
+			if ( stat == 3 )
+				Tessellator.instance.setColorOpaque_I( 0xff0000 );
+			selectFace( renderer, west, up, forward, 9, 10, 11, 12 );
+			renderFace( x, y, z, imb, ExtraTextures.White.getIcon(), renderer, forward );
+		}
+
+		b = world.getLightBrightnessForSkyBlocks( x + up.offsetX, y + up.offsetY, z + up.offsetZ, 0 );
+		if ( sp.isPowered() )
+		{
+			b = 15 << 20 | 15 << 4;
+		}
+
+		Tessellator.instance.setBrightness( b );
+		Tessellator.instance.setColorOpaque_I( 0xffffff );
+		renderer.setRenderBounds( 0, 0, 0, 1, 1, 1 );
+
+		ICellHandler ch = AEApi.instance().registries().cell().getHander( sp.getStorageType() );
+		Icon ico = ch == null ? null : ch.getTopTexture();
+		renderFace( x, y, z, imb, ico == null ? ExtraTextures.MEChest.getIcon() : ico, renderer, up );
+
+		renderer.overrideBlockTexture = null;
+		postRenderInWorld( renderer );
+
+		return result;
+	}
+}

client/render/blocks/RenderNull.java

@@ -0,0 +1,28 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+
+public class RenderNull extends BaseBlockRender
+{
+
+	public RenderNull() {
+		super( false, 20 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		return true;
+	}
+
+}

client/render/blocks/RenderQNB.java

@@ -0,0 +1,122 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.block.AEBaseBlock;
+import appeng.client.texture.ExtraTextures;
+import appeng.tile.qnb.TileQuantumBridge;
+
+public class RenderQNB extends RenderCable
+{
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack item, RenderBlocks renderer)
+	{
+		float px = 2.0f / 16.0f;
+		float maxpx = 14.0f / 16.0f;
+		renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+
+		super.renderInventory( block, item, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		TileQuantumBridge tqb = block.getTileEntity( world, x, y, z );
+		if ( tqb == null )
+			return false;
+
+		renderer.renderAllFaces = true;
+
+		if ( tqb.getBlockType() == AEApi.instance().blocks().blockQuantumLink.block() )
+		{
+			if ( tqb.isFormed() )
+			{
+				EnumSet<ForgeDirection> sides = EnumSet.allOf( ForgeDirection.class );
+				renderCableAt( 0.11D, world, x, y, z, block, renderer, block.getIcon( 0, 0 ), 0.141D, sides );
+				renderCableAt( 0.188D, world, x, y, z, block, renderer, block.getIcon( 0, 0 ), 0.1875D,
+						EnumSet.complementOf( EnumSet.of( ForgeDirection.UNKNOWN ) ) );
+			}
+
+			float px = 2.0f / 16.0f;
+			float maxpx = 14.0f / 16.0f;
+			renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+			renderer.renderStandardBlock( block, x, y, z );
+			// super.renderWorldBlock(world, x, y, z, block, modelId, renderer);
+		}
+		else
+		{
+			if ( !tqb.isFormed() )
+			{
+				float px = 2.0f / 16.0f;
+				float maxpx = 14.0f / 16.0f;
+				renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+				renderer.renderStandardBlock( block, x, y, z );
+			}
+			else if ( tqb.isCorner() )
+			{
+				// renderCableAt(0.11D, world, x, y, z, block, modelId, renderer,
+				// AppEngTextureRegistry.Blocks.MECable.get(), true, 0.0D);
+				renderCableAt( 0.188D, world, x, y, z, block, renderer, ExtraTextures.BlockInterfaceAlternate.getIcon(), 0.05D,
+						EnumSet.complementOf( EnumSet.of( ForgeDirection.UNKNOWN ) ) );
+
+				float px = 4.0f / 16.0f;
+				float maxpx = 12.0f / 16.0f;
+
+				renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+				renderer.renderStandardBlock( block, x, y, z );
+
+				if ( tqb.isPowered() )
+				{
+
+					px = 3.9f / 16.0f;
+					maxpx = 12.1f / 16.0f;
+					renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+
+					int bn = 15;
+					Tessellator.instance.setColorOpaque_F( 1.0F, 1.0F, 1.0F );
+					Tessellator.instance.setBrightness( bn << 20 | bn << 4 );
+					for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
+						renderFace( x, y, z, block, block.getIcon( 0, 0 ), renderer, side );
+
+				}
+			}
+			else
+			{
+				float px = 2.0f / 16.0f;
+				float maxpx = 14.0f / 16.0f;
+				renderer.setRenderBounds( 0, px, px, 1, maxpx, maxpx );
+				renderer.renderStandardBlock( block, x, y, z );
+
+				renderer.setRenderBounds( px, 0, px, maxpx, 1, maxpx );
+				renderer.renderStandardBlock( block, x, y, z );
+
+				renderer.setRenderBounds( px, px, 0, maxpx, maxpx, 1 );
+				renderer.renderStandardBlock( block, x, y, z );
+
+				if ( tqb.isPowered() )
+				{
+					px = -0.01f / 16.0f;
+					maxpx = 16.01f / 16.0f;
+					renderer.setRenderBounds( px, px, px, maxpx, maxpx, maxpx );
+
+					int bn = 15;
+					Tessellator.instance.setColorOpaque_F( 1.0F, 1.0F, 1.0F );
+					Tessellator.instance.setBrightness( bn << 20 | bn << 4 );
+					for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
+						renderFace( x, y, z, block, block.getIcon( 0, 0 ), renderer, side );
+				}
+			}
+		}
+
+		renderer.renderAllFaces = false;
+		return true;
+	}
+
+}

client/render/blocks/RenderQuartzGlass.java

@@ -0,0 +1,153 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+
+public class RenderQuartzGlass extends BaseBlockRender
+{
+
+	public RenderQuartzGlass() {
+		super( false, 0 );
+	}
+
+	boolean isFlush(AEBaseBlock imb, IBlockAccess world, int x, int y, int z)
+	{
+		return isGlass( imb, world, x, y, z );
+	}
+
+	boolean isGlass(AEBaseBlock imb, IBlockAccess world, int x, int y, int z)
+	{
+		return world.getBlockId( x, y, z ) == AEApi.instance().blocks().blockQuartzGlass.block().blockID
+				|| world.getBlockId( x, y, z ) == AEApi.instance().blocks().blockQuartzVibrantGlass.block().blockID;
+	}
+
+	void renderEdge(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer, ForgeDirection side, ForgeDirection direction)
+	{
+		if ( !isFlush( imb, world, x + side.offsetX, y + side.offsetY, z + side.offsetZ ) )
+		{
+			if ( !isFlush( imb, world, x + direction.offsetX, y + direction.offsetY, z + direction.offsetZ ) )
+			{
+				float minX = 0.5f + (side.offsetX + direction.offsetX) / 2.0f;
+				float minY = 0.5f + (side.offsetY + direction.offsetY) / 2.0f;
+				float minZ = 0.5f + (side.offsetZ + direction.offsetZ) / 2.0f;
+				float maxX = 0.5f + (side.offsetX + direction.offsetX) / 2.0f;
+				float maxY = 0.5f + (side.offsetY + direction.offsetY) / 2.0f;
+				float maxZ = 0.5f + (side.offsetZ + direction.offsetZ) / 2.0f;
+
+				if ( 0 == side.offsetX && 0 == direction.offsetX )
+				{
+					minX = 0.0f;
+					maxX = 1.0f;
+				}
+				if ( 0 == side.offsetY && 0 == direction.offsetY )
+				{
+					minY = 0.0f;
+					maxY = 1.0f;
+				}
+				if ( 0 == side.offsetZ && 0 == direction.offsetZ )
+				{
+					minZ = 0.0f;
+					maxZ = 1.0f;
+				}
+
+				if ( maxX <= 0.001f )
+					maxX += 0.9f / 16.0f;
+				if ( maxY <= 0.001f )
+					maxY += 0.9f / 16.0f;
+				if ( maxZ <= 0.001f )
+					maxZ += 0.9f / 16.0f;
+
+				if ( minX >= 0.999f )
+					minX -= 0.9f / 16.0f;
+				if ( minY >= 0.999f )
+					minY -= 0.9f / 16.0f;
+				if ( minZ >= 0.999f )
+					minZ -= 0.9f / 16.0f;
+
+				renderer.setRenderBounds( minX, minY, minZ, maxX, maxY, maxZ );
+
+				switch (side)
+				{
+				case WEST:
+					renderer.renderFaceXNeg( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				case EAST:
+					renderer.renderFaceXPos( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				case NORTH:
+					renderer.renderFaceZNeg( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				case SOUTH:
+					renderer.renderFaceZPos( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				case DOWN:
+					renderer.renderFaceYNeg( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				case UP:
+					renderer.renderFaceYPos( imb, x, y, z, ExtraTextures.GlassFrame.getIcon() );
+					break;
+				default:
+					break;
+				}
+			}
+		}
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.overrideBlockTexture = ExtraTextures.GlassFrame.getIcon();
+		super.renderInventory( block, is, renderer );
+		renderer.overrideBlockTexture = null;
+		super.renderInventory( block, is, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		renderer.setRenderBounds( 0, 0, 0, 1, 1, 1 );
+
+		renderer.overrideBlockTexture = imb.getIcon( 0, 0 );
+		boolean result = renderer.renderStandardBlock( imb, x, y, z );
+
+		renderer.overrideBlockTexture = null;
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.UP, ForgeDirection.EAST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.UP, ForgeDirection.WEST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.UP, ForgeDirection.NORTH );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.UP, ForgeDirection.SOUTH );
+
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.DOWN, ForgeDirection.EAST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.DOWN, ForgeDirection.WEST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.DOWN, ForgeDirection.NORTH );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.DOWN, ForgeDirection.SOUTH );
+
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.EAST, ForgeDirection.UP );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.EAST, ForgeDirection.DOWN );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.EAST, ForgeDirection.NORTH );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.EAST, ForgeDirection.SOUTH );
+
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.WEST, ForgeDirection.UP );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.WEST, ForgeDirection.DOWN );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.WEST, ForgeDirection.NORTH );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.WEST, ForgeDirection.SOUTH );
+
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.NORTH, ForgeDirection.EAST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.NORTH, ForgeDirection.WEST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.NORTH, ForgeDirection.UP );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.NORTH, ForgeDirection.DOWN );
+
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.SOUTH, ForgeDirection.EAST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.SOUTH, ForgeDirection.WEST );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.SOUTH, ForgeDirection.UP );
+		renderEdge( imb, world, x, y, z, renderer, ForgeDirection.SOUTH, ForgeDirection.DOWN );
+
+		return result;
+	}
+
+}

client/render/blocks/RenderQuartzOre.java

@@ -0,0 +1,41 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import appeng.block.AEBaseBlock;
+import appeng.block.solids.OreQuartz;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.texture.ExtraTextures;
+
+public class RenderQuartzOre extends BaseBlockRender
+{
+
+	public RenderQuartzOre() {
+		super( false, 20 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		super.renderInventory( blk, is, renderer );
+		blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.OreQuartzStone.getIcon() );
+		super.renderInventory( blk, is, renderer );
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		OreQuartz blk = (OreQuartz) block;
+		blk.enhanceBrightness = true;
+		super.renderInWorld( block, world, x, y, z, renderer );
+		blk.enhanceBrightness = false;
+
+		blk.getRendererInstance().setTemporaryRenderIcon( ExtraTextures.OreQuartzStone.getIcon() );
+		boolean out = super.renderInWorld( block, world, x, y, z, renderer );
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		return out;
+	}
+}

client/render/blocks/RenderQuartzTorch.java

@@ -0,0 +1,192 @@
+package appeng.client.render.blocks;
+
+import java.util.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.IOrientable;
+import appeng.block.AEBaseBlock;
+import appeng.block.misc.BlockQuartzTorch;
+import appeng.client.render.BaseBlockRender;
+
+public class RenderQuartzTorch extends BaseBlockRender
+{
+
+	public RenderQuartzTorch() {
+		super( false, 20 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		Tessellator tess = Tessellator.instance;
+
+		float Point2 = 6.0f / 16.0f;
+		float Point3 = 7.0f / 16.0f;
+		float Point13 = 10.0f / 16.0f;
+		float Point12 = 9.0f / 16.0f;
+
+		float Onepx = 1.0f / 16.0f;
+		float rbottom = 5.0f / 16.0f;
+		float rtop = 10.0f / 16.0f;
+
+		float bottom = 7.0f / 16.0f;
+		float top = 8.0f / 16.0f;
+
+		float xOff = 0.0f;
+		float yOff = 0.0f;
+		float zOff = 0.0f;
+
+		renderer.setRenderBounds( Point3 + xOff, rbottom + yOff, Point3 + zOff, Point12 + xOff, rtop + yOff, Point12 + zOff );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		renderer.setRenderBounds( Point3 + xOff, rtop + yOff, Point3 + zOff, Point3 + Onepx + xOff, rtop + Onepx + yOff, Point3 + Onepx + zOff );
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		renderer.setRenderBounds( Point12 - Onepx + xOff, rbottom - Onepx + yOff, Point12 - Onepx + zOff, Point12 + xOff, rbottom + yOff, Point12 + zOff );
+
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		blk.getRendererInstance().setTemporaryRenderIcon( Block.hopperBlock.getIcon( 0, 0 ) );
+		renderer.renderAllFaces = true;
+
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point2 + zOff, Point13 + xOff, top + yOff, Point3 + zOff );
+
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point12 + zOff, Point13 + xOff, top + yOff, Point13 + zOff );
+
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point3 + zOff, Point3 + xOff, top + yOff, Point12 + zOff );
+
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+		renderer.setRenderBounds( Point12 + xOff, bottom + yOff, Point3 + zOff, Point13 + xOff, top + yOff, Point12 + zOff );
+
+		renderInvBlock( EnumSet.allOf( ForgeDirection.class ), blk, tess, 0xffffff, renderer );
+
+		renderer.renderAllFaces = false;
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		BlockQuartzTorch blk = (BlockQuartzTorch) block;
+
+		IOrientable te = getOrientable( block, world, x, y, z );
+
+		float Point2 = 6.0f / 16.0f;
+		float Point3 = 7.0f / 16.0f;
+		float Point13 = 10.0f / 16.0f;
+		float Point12 = 9.0f / 16.0f;
+
+		float Onepx = 1.0f / 16.0f;
+		float rbottom = 5.0f / 16.0f;
+		float rtop = 10.0f / 16.0f;
+
+		float bottom = 7.0f / 16.0f;
+		float top = 8.0f / 16.0f;
+
+		float xOff = 0.0f;
+		float yOff = 0.0f;
+		float zOff = 0.0f;
+
+		renderer.renderAllFaces = true;
+		if ( te != null )
+		{
+			ForgeDirection forward = te.getUp();
+			xOff = forward.offsetX * -(4.0f / 16.0f);
+			yOff = forward.offsetY * -(4.0f / 16.0f);
+			zOff = forward.offsetZ * -(4.0f / 16.0f);
+		}
+
+		renderer.setRenderBounds( Point3 + xOff, rbottom + yOff, Point3 + zOff, Point12 + xOff, rtop + yOff, Point12 + zOff );
+		super.renderInWorld( block, world, x, y, z, renderer );
+
+		int r = (x + y + z) % 2;
+		if ( r == 0 )
+		{
+			renderer.setRenderBounds( Point3 + xOff, rtop + yOff, Point3 + zOff, Point3 + Onepx + xOff, rtop + Onepx + yOff, Point3 + Onepx + zOff );
+			super.renderInWorld( block, world, x, y, z, renderer );
+
+			renderer.setRenderBounds( Point12 - Onepx + xOff, rbottom - Onepx + yOff, Point12 - Onepx + zOff, Point12 + xOff, rbottom + yOff, Point12 + zOff );
+			super.renderInWorld( block, world, x, y, z, renderer );
+		}
+		else
+		{
+			renderer.setRenderBounds( Point3 + xOff, rbottom - Onepx + yOff, Point3 + zOff, Point3 + Onepx + xOff, rbottom + yOff, Point3 + Onepx + zOff );
+			super.renderInWorld( block, world, x, y, z, renderer );
+
+			renderer.setRenderBounds( Point12 - Onepx + xOff, rtop + yOff, Point12 - Onepx + zOff, Point12 + xOff, rtop + Onepx + yOff, Point12 + zOff );
+			super.renderInWorld( block, world, x, y, z, renderer );
+		}
+
+		blk.getRendererInstance().setTemporaryRenderIcon( Block.hopperBlock.getIcon( 0, 0 ) );
+
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point2 + zOff, Point13 + xOff, top + yOff, Point3 + zOff );
+		boolean out = renderer.renderStandardBlock( blk, x, y, z );
+
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point12 + zOff, Point13 + xOff, top + yOff, Point13 + zOff );
+		renderer.renderStandardBlock( blk, x, y, z );
+
+		renderer.setRenderBounds( Point2 + xOff, bottom + yOff, Point3 + zOff, Point3 + xOff, top + yOff, Point12 + zOff );
+		renderer.renderStandardBlock( blk, x, y, z );
+
+		renderer.setRenderBounds( Point12 + xOff, bottom + yOff, Point3 + zOff, Point13 + xOff, top + yOff, Point12 + zOff );
+		renderer.renderStandardBlock( blk, x, y, z );
+
+		if ( te != null )
+		{
+			ForgeDirection forward = te.getUp();
+			switch (forward)
+			{
+			case EAST:
+				renderer.setRenderBounds( 0, bottom + yOff, bottom + zOff, Point2 + xOff, top + yOff, top + zOff );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			case WEST:
+				renderer.setRenderBounds( Point13 + xOff, bottom + yOff, bottom + zOff, 1.0, top + yOff, top + zOff );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			case NORTH:
+				renderer.setRenderBounds( bottom + xOff, bottom + yOff, Point13 + zOff, top + xOff, top + yOff, 1.0 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			case SOUTH:
+				renderer.setRenderBounds( bottom + xOff, bottom + yOff, 0, top + xOff, top + yOff, Point2 + zOff );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			case UP:
+				renderer.setRenderBounds( Point2, 0, Point2, Point3, bottom + yOff, Point3 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point2, 0, Point12, Point3, bottom + yOff, Point13 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point12, 0, Point2, Point13, bottom + yOff, Point3 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point12, 0, Point12, Point13, bottom + yOff, Point13 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			case DOWN:
+				renderer.setRenderBounds( Point2, top + yOff, Point2, Point3, 1.0, Point3 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point2, top + yOff, Point12, Point3, 1.0, Point13 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point12, top + yOff, Point2, Point13, 1.0, Point3 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				renderer.setRenderBounds( Point12, top + yOff, Point12, Point13, 1.0, Point13 );
+				renderer.renderStandardBlock( blk, x, y, z );
+				break;
+			default:
+			}
+		}
+
+		renderer.renderAllFaces = false;
+		blk.getRendererInstance().setTemporaryRenderIcon( null );
+
+		return out;
+	}
+}

client/render/blocks/RenderSpatialPylon.java

@@ -0,0 +1,188 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Icon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.render.BlockRenderInfo;
+import appeng.client.texture.ExtraTextures;
+import appeng.tile.spatial.TileSpatialPylon;
+
+public class RenderSpatialPylon extends BaseBlockRender
+{
+
+	public RenderSpatialPylon() {
+		super( false, 0 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.overrideBlockTexture = ExtraTextures.BlockSpatialPylon_dim.getIcon();
+		super.renderInventory( block, is, renderer );
+		renderer.overrideBlockTexture = null;
+		super.renderInventory( block, is, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		renderer.setRenderBounds( 0, 0, 0, 1, 1, 1 );
+
+		TileSpatialPylon sp = imb.getTileEntity( world, x, y, z );
+
+		int displayBits = sp.getDisplayBits();
+		ForgeDirection ori = ForgeDirection.UNKNOWN;
+
+		if ( displayBits != 0 )
+		{
+			if ( (displayBits & sp.DISPLAY_Z) == sp.DISPLAY_X )
+			{
+				ori = ForgeDirection.EAST;
+				if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMAX )
+				{
+					renderer.uvRotateEast = 1;
+					renderer.uvRotateWest = 2;
+					renderer.uvRotateTop = 2;
+					renderer.uvRotateBottom = 1;
+				}
+				else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMIN )
+				{
+					renderer.uvRotateEast = 2;
+					renderer.uvRotateWest = 1;
+					renderer.uvRotateTop = 1;
+					renderer.uvRotateBottom = 2;
+				}
+				else
+				{
+					renderer.uvRotateEast = 1;
+					renderer.uvRotateWest = 1;
+					renderer.uvRotateTop = 1;
+					renderer.uvRotateBottom = 1;
+				}
+			}
+
+			else if ( (displayBits & sp.DISPLAY_Z) == sp.DISPLAY_Y )
+			{
+				ori = ForgeDirection.UP;
+				if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMAX )
+				{
+					renderer.uvRotateNorth = 3;
+					renderer.uvRotateSouth = 3;
+					renderer.uvRotateEast = 3;
+					renderer.uvRotateWest = 3;
+				}
+			}
+
+			else if ( (displayBits & sp.DISPLAY_Z) == sp.DISPLAY_Z )
+			{
+				ori = ForgeDirection.NORTH;
+				if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMAX )
+				{
+					renderer.uvRotateSouth = 1;
+					renderer.uvRotateNorth = 2;
+				}
+				else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMIN )
+				{
+					renderer.uvRotateNorth = 1;
+					renderer.uvRotateSouth = 2;
+					renderer.uvRotateTop = 3;
+					renderer.uvRotateBottom = 3;
+				}
+				else
+				{
+					renderer.uvRotateNorth = 1;
+					renderer.uvRotateSouth = 2;
+				}
+			}
+
+			BlockRenderInfo bri = imb.getRendererInstance();
+			bri.setTemporaryRenderIcon( null );
+			bri.setTemporaryRenderIcons( getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.UP ),
+					getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.DOWN ),
+					getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.SOUTH ),
+					getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.NORTH ),
+					getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.EAST ),
+					getBlockTextureFromSideOutside( imb, sp, displayBits, ori, ForgeDirection.WEST ) );
+
+			boolean r = renderer.renderStandardBlock( imb, x, y, z );
+
+			if ( (displayBits & sp.DISPLAY_POWEREDENABLED) == sp.DISPLAY_POWEREDENABLED )
+			{
+				int bn = 15;
+				Tessellator.instance.setBrightness( bn << 20 | bn << 4 );
+				Tessellator.instance.setColorOpaque_I( 0xffffff );
+
+				for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS)
+					renderFace( x, y, z, imb, getBlockTextureFromSideInside( imb, sp, displayBits, ori, d ), renderer, d );
+			}
+			else
+			{
+				bri.setTemporaryRenderIcon( null );
+				bri.setTemporaryRenderIcons( getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.UP ),
+						getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.DOWN ),
+						getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.SOUTH ),
+						getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.NORTH ),
+						getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.EAST ),
+						getBlockTextureFromSideInside( imb, sp, displayBits, ori, ForgeDirection.WEST ) );
+
+				renderer.renderStandardBlock( imb, x, y, z );
+			}
+
+			bri.setTemporaryRenderIcon( null );
+			renderer.uvRotateEast = renderer.uvRotateWest = renderer.uvRotateNorth = renderer.uvRotateSouth = renderer.uvRotateTop = renderer.uvRotateBottom = 0;
+
+			return r;
+		}
+
+		renderer.overrideBlockTexture = imb.getIcon( 0, 0 );
+		boolean result = renderer.renderStandardBlock( imb, x, y, z );
+
+		renderer.overrideBlockTexture = ExtraTextures.BlockSpatialPylon_dim.getIcon();
+		result = renderer.renderStandardBlock( imb, x, y, z );
+
+		renderer.overrideBlockTexture = null;
+		return result;
+	}
+
+	private Icon getBlockTextureFromSideOutside(AEBaseBlock blk, TileSpatialPylon sp, int displayBits, ForgeDirection ori, ForgeDirection dir)
+	{
+
+		if ( ori.equals( dir ) || ori.getOpposite().equals( dir ) )
+			return blk.getRendererInstance().getTexture( dir );
+
+		if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_MIDDLE )
+			return ExtraTextures.BlockSpatialPylonC.getIcon();
+
+		else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMIN )
+			return ExtraTextures.BlockSpatialPylonE.getIcon();
+
+		else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMAX )
+			return ExtraTextures.BlockSpatialPylonE.getIcon();
+
+		return blk.getIcon( 0, 0 );
+	}
+
+	private Icon getBlockTextureFromSideInside(AEBaseBlock blk, TileSpatialPylon sp, int displayBits, ForgeDirection ori, ForgeDirection dir)
+	{
+		boolean good = (displayBits & sp.DISPLAY_ENABLED) == sp.DISPLAY_ENABLED;
+
+		if ( ori.equals( dir ) || ori.getOpposite().equals( dir ) )
+			return good ? ExtraTextures.BlockSpatialPylon_dim.getIcon() : ExtraTextures.BlockSpatialPylon_red.getIcon();
+
+		if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_MIDDLE )
+			return good ? ExtraTextures.BlockSpatialPylonC_dim.getIcon() : ExtraTextures.BlockSpatialPylonC_red.getIcon();
+
+		else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMIN )
+			return good ? ExtraTextures.BlockSpatialPylonE_dim.getIcon() : ExtraTextures.BlockSpatialPylonE_red.getIcon();
+
+		else if ( (displayBits & sp.DISPLAY_MIDDLE) == sp.DISPLAY_ENDMAX )
+			return good ? ExtraTextures.BlockSpatialPylonE_dim.getIcon() : ExtraTextures.BlockSpatialPylonE_red.getIcon();
+
+		return blk.getIcon( 0, 0 );
+	}
+}

client/render/blocks/RenderStorageMonitor.java

@@ -0,0 +1,101 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import appeng.api.implementations.IPartStorageMonitor;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.tile.AEBaseTile;
+
+public class RenderStorageMonitor extends BaseBlockRender
+{
+
+	public RenderStorageMonitor() {
+		super( true, 30 );
+	}
+
+	@Override
+	public void renderTile(AEBaseBlock blk, AEBaseTile tile, Tessellator tess, double x, double y, double z, float f,
+			RenderBlocks rinstance)
+	{
+		IPartStorageMonitor monitor = (IPartStorageMonitor) tile;
+		IAEItemStack is = ((IAEItemStack) monitor.getDisplayed());
+
+		if ( is != null && monitor.isPowered() )
+		{
+			FontRenderer fr = Minecraft.getMinecraft().fontRenderer;
+
+			// applyTESRRotation( x, y, z, monitor.getForward(), monitor.getUp()
+			// );
+
+			GL11.glPushMatrix();
+			try
+			{
+				ItemStack sis = is.getItemStack();
+				sis.stackSize = 1;
+
+				GL11.glTranslatef( 0.0f, -0.05f, -0.25f );
+				GL11.glScalef( 1.0f / 1.5f, 1.0f / 1.5f, 1.0f / 1.5f );
+				GL11.glScalef( 1.0f, -1.0f, 0.005f );
+
+				int k = sis.itemID;
+				Block block = (k < Block.blocksList.length ? Block.blocksList[k] : null);
+				if ( sis.getItemSpriteNumber() == 0 && block != null
+						&& RenderBlocks.renderItemIn3d( Block.blocksList[k].getRenderType() ) )
+				{
+					GL11.glRotatef( 25.0f, 1.0f, 0.0f, 0.0f );
+					GL11.glRotatef( 15.0f, 0.0f, 1.0f, 0.0f );
+					GL11.glRotatef( 30.0f, 0.0f, 1.0f, 0.0f );
+				}
+				int br = 16 << 20 | 16 << 4;
+				int var11 = br % 65536;
+				int var12 = br / 65536;
+				OpenGlHelper.setLightmapTextureCoords( OpenGlHelper.lightmapTexUnit, var11 * 0.8F, var12 * 0.8F );
+
+				GL11.glColor4f( 1.0F, 1.0F, 1.0F, 1.0F );
+
+				GL11.glDisable( GL11.GL_LIGHTING );
+				GL11.glDisable( GL12.GL_RESCALE_NORMAL );
+				tess.setColorOpaque_F( 1.0f, 1.0f, 1.0f );
+
+				doRenderItem( sis, tile );
+			}
+			catch (Exception err)
+			{
+				err.printStackTrace();
+			}
+
+			GL11.glPopMatrix();
+
+			GL11.glTranslatef( 0.0f, 0.14f, -0.24f );
+			GL11.glScalef( 1.0f / 62.0f, 1.0f / 62.0f, 1.0f / 62.0f );
+
+			long qty = is.getStackSize();
+			if ( qty > 999999999999L )
+				qty = 999999999999L;
+
+			String msg = Long.toString( qty );
+			if ( qty > 1000000000 )
+				msg = Long.toString( qty / 1000000000 ) + "B";
+			else if ( qty > 1000000 )
+				msg = Long.toString( qty / 1000000 ) + "M";
+			else if ( qty > 9999 )
+				msg = Long.toString( qty / 1000 ) + "K";
+
+			int width = fr.getStringWidth( msg );
+			GL11.glTranslatef( -0.5f * width, 0.0f, -1.0f );
+			fr.drawString( msg, 0, 0, 0 );
+		}
+	}
+
+}

client/render/blocks/RenderTinyTNT.java

@@ -0,0 +1,33 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+
+public class RenderTinyTNT extends BaseBlockRender
+{
+
+	public RenderTinyTNT() {
+		super( false, 0 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock block, ItemStack is, RenderBlocks renderer)
+	{
+		renderer.setRenderBounds( 0.25f, 0.0f, 0.25f, 0.75f, 0.5f, 0.75f );
+		super.renderInventory( block, is, renderer );
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock imb, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		renderer.renderAllFaces = true;
+		renderer.setRenderBounds( 0.25f, 0.0f, 0.25f, 0.75f, 0.5f, 0.75f );
+		boolean out = super.renderInWorld( imb, world, x, y, z, renderer );
+		renderer.renderAllFaces = false;
+		return out;
+	}
+
+}

client/render/blocks/RendererCableBus.java

@@ -0,0 +1,51 @@
+package appeng.client.render.blocks;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.IBlockAccess;
+import appeng.block.AEBaseBlock;
+import appeng.client.render.BaseBlockRender;
+import appeng.client.render.BusRenderer;
+import appeng.tile.AEBaseTile;
+import appeng.tile.networking.TileCableBus;
+
+public class RendererCableBus extends BaseBlockRender
+{
+
+	public RendererCableBus() {
+		super( true, 30 );
+	}
+
+	@Override
+	public void renderInventory(AEBaseBlock blk, ItemStack is, RenderBlocks renderer)
+	{
+		// nothin.
+	}
+
+	@Override
+	public boolean renderInWorld(AEBaseBlock block, IBlockAccess world, int x, int y, int z, RenderBlocks renderer)
+	{
+		AEBaseTile t = block.getTileEntity( world, x, y, z );
+
+		if ( t instanceof TileCableBus )
+		{
+			BusRenderer.instance.renderer.renderAllFaces = true;
+			BusRenderer.instance.renderer.blockAccess = renderer.blockAccess;
+			((TileCableBus) t).cb.renderStatic( x, y, z );
+			BusRenderer.instance.renderer.renderAllFaces = false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void renderTile(AEBaseBlock block, AEBaseTile t, Tessellator tess, double x, double y, double z, float f, RenderBlocks renderer)
+	{
+		if ( t instanceof TileCableBus )
+		{
+			((TileCableBus) t).cb.renderDynamic( x, y, z );
+		}
+	}
+
+}