Reimplemented cable and parts rendering.

src/main/java/appeng/client/render/cablebus/CableBuilder.java

@@ -0,0 +1,673 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+
+import com.google.common.base.Function;
+
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+
+import appeng.api.util.AECableType;
+import appeng.api.util.AEColor;
+
+
+/**
+ * A helper class that builds quads for cable connections.
+ */
+class CableBuilder
+{
+
+	private final VertexFormat format;
+
+	// Textures for the cable core types, one per type/color pair
+	private final EnumMap<CableCoreType, EnumMap<AEColor, TextureAtlasSprite>> coreTextures;
+
+	// Textures for rendering the actual connection cubes, one per type/color pair
+	private final EnumMap<AECableType, EnumMap<AEColor, TextureAtlasSprite>> connectionTextures;
+
+	private final SmartCableTextures smartCableTextures;
+
+	CableBuilder( VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+	{
+		this.format = format;
+		this.coreTextures = new EnumMap<>( CableCoreType.class );
+
+		for( CableCoreType type : CableCoreType.values() )
+		{
+			EnumMap<AEColor, TextureAtlasSprite> colorTextures = new EnumMap<>( AEColor.class );
+
+			for( AEColor color : AEColor.values() )
+			{
+				colorTextures.put( color, bakedTextureGetter.apply( type.getTexture( color ) ) );
+			}
+
+			coreTextures.put( type, colorTextures );
+		}
+
+		this.connectionTextures = new EnumMap<>( AECableType.class );
+
+		for( AECableType type : AECableType.VALIDCABLES )
+		{
+			EnumMap<AEColor, TextureAtlasSprite> colorTextures = new EnumMap<>( AEColor.class );
+
+			for( AEColor color : AEColor.values() )
+			{
+				colorTextures.put( color, bakedTextureGetter.apply( type.getConnectionTexture( color ) ) );
+			}
+
+			connectionTextures.put( type, colorTextures );
+		}
+
+		smartCableTextures = new SmartCableTextures( bakedTextureGetter );
+	}
+
+	/**
+	 * Adds the core of a cable to the given list of quads.
+	 *
+	 * The type of cable core is automatically deduced from the given cable type.
+	 */
+	public void addCableCore( AECableType cableType, AEColor color, List<BakedQuad> quadsOut )
+	{
+		switch( cableType )
+		{
+			case GLASS:
+				addCableCore( CableCoreType.GLASS, color, quadsOut );
+				break;
+			case COVERED:
+			case SMART:
+				addCableCore( CableCoreType.COVERED, color, quadsOut );
+				break;
+			case DENSE:
+				addCableCore( CableCoreType.DENSE, color, quadsOut );
+				break;
+			default:
+		}
+	}
+
+	public void addCableCore( CableCoreType coreType, AEColor color, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = coreTextures.get( coreType ).get( color );
+		cubeBuilder.setTexture( texture );
+
+		switch( coreType )
+		{
+			case GLASS:
+				cubeBuilder.addCube( 6, 6, 6, 10, 10, 10 );
+				break;
+			case COVERED:
+				cubeBuilder.addCube( 5, 5, 5, 11, 11, 11 );
+				break;
+			case DENSE:
+				cubeBuilder.addCube( 3, 3, 3, 13, 13, 13 );
+				break;
+		}
+	}
+
+	public void addGlassConnection( EnumFacing facing, AEColor cableColor, AECableType connectionType, boolean cableBusAdjacent, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		// We render all faces except the one on the connection side
+		cubeBuilder.setDrawFaces( EnumSet.complementOf( EnumSet.of( facing ) ) );
+
+		// For to-machine connections, use a thicker end-cap for the connection
+		if( connectionType != AECableType.GLASS && !cableBusAdjacent )
+		{
+			TextureAtlasSprite texture = connectionTextures.get( AECableType.COVERED ).get( cableColor );
+			cubeBuilder.setTexture( texture );
+
+			addBigCoveredCableSizedCube( facing, cubeBuilder );
+		}
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.GLASS ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 6, 0, 6, 10, 6, 10 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 10, 6, 6, 16, 10, 10 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 6, 6, 0, 10, 10, 6 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 6, 6, 10, 10, 10, 16 );
+				break;
+			case UP:
+				cubeBuilder.addCube( 6, 10, 6, 10, 16, 10 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( 0, 6, 6, 6, 10, 10 );
+				break;
+		}
+	}
+
+	public void addStraightGlassConnection( EnumFacing facing, AEColor cableColor, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		// We render all faces except the connection caps. We can do this because the glass cable is the smallest one
+		// and its ends will always be covered by something
+		cubeBuilder.setDrawFaces( EnumSet.complementOf( EnumSet.of( facing, facing.getOpposite() ) ) );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.GLASS ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		switch( facing )
+		{
+			case DOWN:
+			case UP:
+				cubeBuilder.addCube( 6, 0, 6, 10, 16, 10 );
+				break;
+			case NORTH:
+			case SOUTH:
+				cubeBuilder.addCube( 6, 6, 0, 10, 10, 16 );
+				break;
+			case EAST:
+			case WEST:
+				cubeBuilder.addCube( 0, 6, 6, 16, 10, 10 );
+				break;
+		}
+	}
+
+	public void addConstrainedGlassConnection( EnumFacing facing, AEColor cableColor, int distanceFromEdge, List<BakedQuad> quadsOut )
+	{
+
+		// Glass connections reach only 6 voxels from the edge
+		if( distanceFromEdge >= 6 )
+		{
+			return;
+		}
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.GLASS ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 6, distanceFromEdge, 6, 10, 6, 10 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 10, 6, 6, 16 - distanceFromEdge, 10, 10 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 6, 6, distanceFromEdge, 10, 10, 6 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 6, 6, 10, 10, 10, 16 - distanceFromEdge );
+				break;
+			case UP:
+				cubeBuilder.addCube( 6, 10, 6, 10, 16 - distanceFromEdge, 10 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( distanceFromEdge, 6, 6, 6, 10, 10 );
+				break;
+		}
+	}
+
+	public void addCoveredConnection( EnumFacing facing, AEColor cableColor, AECableType connectionType, boolean cableBusAdjacent, List<BakedQuad> quadsOut )
+	{
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		// We render all faces except the one on the connection side
+		cubeBuilder.setDrawFaces( EnumSet.complementOf( EnumSet.of( facing ) ) );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.COVERED ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		// Draw a covered connection, if anything but glass is requested
+		if( connectionType != AECableType.GLASS && !cableBusAdjacent )
+		{
+			addBigCoveredCableSizedCube( facing, cubeBuilder );
+		}
+
+		addCoveredCableSizedCube( facing, cubeBuilder );
+	}
+
+	public void addStraightCoveredConnection( EnumFacing facing, AEColor cableColor, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.COVERED ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		setStraightCableUVs( cubeBuilder, facing, 5, 11 );
+
+		addStraightCoveredCableSizedCube( facing, cubeBuilder );
+
+
+
+	}
+
+	private static void setStraightCableUVs( CubeBuilder cubeBuilder, EnumFacing facing, int x, int y )
+	{
+		switch( facing )
+		{
+			case DOWN:
+			case UP:
+				cubeBuilder.setCustomUv( EnumFacing.NORTH, x, 0, y, x );
+				cubeBuilder.setCustomUv( EnumFacing.EAST, x, 0, y, x );
+				cubeBuilder.setCustomUv( EnumFacing.SOUTH, x, 0, y, x );
+				cubeBuilder.setCustomUv( EnumFacing.WEST, x, 0, y, x );
+				break;
+			case EAST:
+			case WEST:
+				cubeBuilder.setCustomUv( EnumFacing.UP, 0, x, x, y );
+				cubeBuilder.setCustomUv( EnumFacing.DOWN, 0, x, x, y );
+				cubeBuilder.setCustomUv( EnumFacing.NORTH, 0, x, x, y );
+				cubeBuilder.setCustomUv( EnumFacing.SOUTH, 0, x, x, y );
+				break;
+			case NORTH:
+			case SOUTH:
+				cubeBuilder.setCustomUv( EnumFacing.UP, x, 0, y, x );
+				cubeBuilder.setCustomUv( EnumFacing.DOWN, x, 0, y, x );
+				cubeBuilder.setCustomUv( EnumFacing.EAST, 0, x, x, y );
+				cubeBuilder.setCustomUv( EnumFacing.WEST, 0, x, x, y );
+				break;
+		}
+	}
+
+	public void addConstrainedCoveredConnection( EnumFacing facing, AEColor cableColor, int distanceFromEdge, List<BakedQuad> quadsOut )
+	{
+
+		// The core of a covered cable reaches up to 5 voxels from the block edge, so
+		// drawing a connection can only occur from there onwards
+		if( distanceFromEdge >= 5 )
+		{
+			return;
+		}
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.COVERED ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		addCoveredCableSizedCube( facing, distanceFromEdge, cubeBuilder );
+
+	}
+
+	public void addSmartConnection( EnumFacing facing, AEColor cableColor, AECableType connectionType, boolean cableBusAdjacent, int channels, List<BakedQuad> quadsOut )
+	{
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		// We render all faces except the one on the connection side
+		cubeBuilder.setDrawFaces( EnumSet.complementOf( EnumSet.of( facing ) ) );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.SMART ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		TextureAtlasSprite oddChannel = smartCableTextures.getOddTextureForChannels( channels );
+		TextureAtlasSprite evenChannel = smartCableTextures.getEvenTextureForChannels( channels );
+
+		// For to-machine connections, use a thicker end-cap for the connection
+		if( connectionType != AECableType.GLASS && !cableBusAdjacent )
+		{
+			addBigCoveredCableSizedCube( facing, cubeBuilder );
+
+			// Render the channel indicators brightly lit at night
+			cubeBuilder.setRenderFullBright( true );
+
+			cubeBuilder.setTexture( oddChannel );
+			cubeBuilder.setColorRGB( cableColor.blackVariant );
+			addBigCoveredCableSizedCube( facing, cubeBuilder );
+
+			cubeBuilder.setTexture( evenChannel );
+			cubeBuilder.setColorRGB( cableColor.whiteVariant );
+			addBigCoveredCableSizedCube( facing, cubeBuilder );
+
+			// Reset back to normal rendering for the rest
+			cubeBuilder.setRenderFullBright( false );
+			cubeBuilder.setTexture( texture );
+		}
+
+		addCoveredCableSizedCube( facing, cubeBuilder );
+
+		// Render the channel indicators brightly lit at night
+		cubeBuilder.setRenderFullBright( true );
+
+		cubeBuilder.setTexture( oddChannel );
+		cubeBuilder.setColorRGB( cableColor.blackVariant );
+		addCoveredCableSizedCube( facing, cubeBuilder );
+
+		cubeBuilder.setTexture( evenChannel );
+		cubeBuilder.setColorRGB( cableColor.whiteVariant );
+		addCoveredCableSizedCube( facing, cubeBuilder );
+
+	/*	TODO: this.setSmartConnectionRotations( of, renderer );
+		renderer.uvRotateBottom = renderer.uvRotateEast = renderer.uvRotateNorth = renderer.uvRotateSouth = renderer.uvRotateTop = renderer.uvRotateWest = 0;*/
+	}
+
+	public void addStraightSmartConnection( EnumFacing facing, AEColor cableColor, int channels, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.SMART ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		setStraightCableUVs( cubeBuilder, facing, 5, 11 );
+
+		addStraightCoveredCableSizedCube( facing, cubeBuilder );
+
+		TextureAtlasSprite oddChannel = smartCableTextures.getOddTextureForChannels( channels );
+		TextureAtlasSprite evenChannel = smartCableTextures.getEvenTextureForChannels( channels );
+
+		// Render the channel indicators brightly lit at night
+		cubeBuilder.setRenderFullBright( true );
+
+		cubeBuilder.setTexture( oddChannel );
+		cubeBuilder.setColorRGB( cableColor.blackVariant );
+		addStraightCoveredCableSizedCube( facing, cubeBuilder );
+
+		cubeBuilder.setTexture( evenChannel );
+		cubeBuilder.setColorRGB( cableColor.whiteVariant );
+		addStraightCoveredCableSizedCube( facing, cubeBuilder );
+	}
+
+	public void addConstrainedSmartConnection( EnumFacing facing, AEColor cableColor, int distanceFromEdge, int channels, List<BakedQuad> quadsOut )
+	{
+		// Same as with covered cables, the smart cable's core extends up to 5 voxels away from the edge.
+		// Drawing a connection to any point before that point is fruitless
+		if( distanceFromEdge >= 5 )
+		{
+			return;
+		}
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.SMART ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		addCoveredCableSizedCube( facing, distanceFromEdge, cubeBuilder );
+
+		TextureAtlasSprite oddChannel = smartCableTextures.getOddTextureForChannels( channels );
+		TextureAtlasSprite evenChannel = smartCableTextures.getEvenTextureForChannels( channels );
+
+		// Render the channel indicators brightly lit at night
+		cubeBuilder.setRenderFullBright( true );
+
+		cubeBuilder.setTexture( oddChannel );
+		cubeBuilder.setColorRGB( cableColor.blackVariant );
+		addCoveredCableSizedCube( facing, distanceFromEdge, cubeBuilder );
+
+		cubeBuilder.setTexture( evenChannel );
+		cubeBuilder.setColorRGB( cableColor.whiteVariant );
+		addCoveredCableSizedCube( facing, distanceFromEdge, cubeBuilder );
+	}
+
+	public void addDenseConnection( EnumFacing facing, AEColor cableColor, AECableType connectionType, boolean cableBusAdjacent, int channels, List<BakedQuad> quadsOut )
+	{
+		// Dense cables only render their connections as dense if the adjacent blocks actually wants that
+		if( connectionType == AECableType.SMART )
+		{
+			addSmartConnection( facing, cableColor, connectionType, cableBusAdjacent, channels, quadsOut );
+			return;
+		}
+		else if( connectionType != AECableType.DENSE )
+		{
+			addCoveredConnection( facing, cableColor, connectionType, cableBusAdjacent, quadsOut );
+			return;
+		}
+
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		// We render all faces except the one on the connection side
+		cubeBuilder.setDrawFaces( EnumSet.complementOf( EnumSet.of( facing ) ) );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.DENSE ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		addDenseCableSizedCube( facing, cubeBuilder );
+
+		// Dense cables show used channels in groups of 4, rounded up
+		channels = (channels + 3) / 4;
+
+		TextureAtlasSprite oddChannel = smartCableTextures.getOddTextureForChannels( channels );
+		TextureAtlasSprite evenChannel = smartCableTextures.getEvenTextureForChannels( channels );
+
+		// Render the channel indicators brightly lit at night
+		cubeBuilder.setRenderFullBright( true );
+
+		cubeBuilder.setTexture( oddChannel );
+		cubeBuilder.setColorRGB( cableColor.blackVariant );
+		addDenseCableSizedCube( facing, cubeBuilder );
+
+		cubeBuilder.setTexture( evenChannel );
+		cubeBuilder.setColorRGB( cableColor.whiteVariant );
+		addDenseCableSizedCube( facing, cubeBuilder );
+
+		// Reset back to normal rendering for the rest
+		cubeBuilder.setRenderFullBright( false );
+		cubeBuilder.setTexture( texture );
+
+	}
+
+	public void addStraightDenseConnection( EnumFacing facing, AEColor cableColor, int channels, List<BakedQuad> quadsOut )
+	{
+		CubeBuilder cubeBuilder = new CubeBuilder( format, quadsOut );
+
+		TextureAtlasSprite texture = connectionTextures.get( AECableType.DENSE ).get( cableColor );
+		cubeBuilder.setTexture( texture );
+
+		setStraightCableUVs( cubeBuilder, facing, 5, 11 );
+
+		addStraightDenseCableSizedCube( facing, cubeBuilder );
+
+		// Dense cables show used channels in groups of 4, rounded up
+		channels = (channels + 3) / 4;
+
+		TextureAtlasSprite oddChannel = smartCableTextures.getOddTextureForChannels( channels );
+		TextureAtlasSprite evenChannel = smartCableTextures.getEvenTextureForChannels( channels );
+
+		// Render the channel indicators brightly lit at night
+		cubeBuilder.setRenderFullBright( true );
+
+		cubeBuilder.setTexture( oddChannel );
+		cubeBuilder.setColorRGB( cableColor.blackVariant );
+		addStraightDenseCableSizedCube( facing, cubeBuilder );
+
+		cubeBuilder.setTexture( evenChannel );
+		cubeBuilder.setColorRGB( cableColor.whiteVariant );
+		addStraightDenseCableSizedCube( facing, cubeBuilder );
+	}
+
+
+	private static void addDenseCableSizedCube( EnumFacing facing, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 4, 0, 4, 12, 5, 12 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 11, 4, 4, 16, 12, 12 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 4, 4, 0, 12, 12, 5 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 4, 4, 11, 12, 12, 16 );
+				break;
+			case UP:
+				cubeBuilder.addCube( 4, 11, 4, 12, 16, 12 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( 0, 4, 4, 5, 12, 12 );
+				break;
+		}
+	}
+
+	// Adds a cube to the given cube builder that has the size of a dense cable connection and spans the entire block for the given direction
+	private static void addStraightDenseCableSizedCube( EnumFacing facing, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+			case UP:
+				cubeBuilder.addCube( 3, 0, 3, 13, 16, 13 );
+				break;
+			case EAST:
+			case WEST:
+				/*renderer.uvRotateEast = renderer.uvRotateWest = 1;
+				renderer.uvRotateBottom = renderer.uvRotateTop = 1;*/
+				cubeBuilder.addCube( 0, 3, 3, 16, 13, 13 );
+				break;
+			case NORTH:
+			case SOUTH:
+				// TODO renderer.uvRotateNorth = renderer.uvRotateSouth = 1;
+				cubeBuilder.addCube( 3, 3, 0, 13, 13, 16 );
+				break;
+		}
+	}
+
+	// Adds a cube to the given cube builder that has the size of a covered cable connection from the core of the cable to the given face
+	private static void addCoveredCableSizedCube( EnumFacing facing, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 6, 0, 6, 10, 5, 10 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 11, 6, 6, 16, 10, 10 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 6, 6, 0, 10, 10, 5 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 6, 6, 11, 10, 10, 16 );
+				break;
+			case UP:
+				cubeBuilder.addCube( 6, 11, 6, 10, 16, 10 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( 0, 6, 6, 5, 10, 10 );
+				break;
+		}
+	}
+
+	// Adds a cube to the given cube builder that has the size of a covered cable connection and spans the entire block for the given direction
+	private static void addStraightCoveredCableSizedCube( EnumFacing facing, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+			case UP:
+				cubeBuilder.addCube( 5, 0, 5, 11, 16, 11 );
+				break;
+			case EAST:
+			case WEST:
+				/*renderer.uvRotateEast = renderer.uvRotateWest = 1;
+				renderer.uvRotateBottom = renderer.uvRotateTop = 1;*/
+				cubeBuilder.addCube( 0, 5, 5, 16, 11, 11 );
+				break;
+			case NORTH:
+			case SOUTH:
+				// TODO renderer.uvRotateNorth = renderer.uvRotateSouth = 1;
+				cubeBuilder.addCube( 5, 5, 0, 11, 11, 16 );
+				break;
+		}
+	}
+
+	private static void addCoveredCableSizedCube( EnumFacing facing, int distanceFromEdge, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 6, distanceFromEdge, 6, 10, 5, 10 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 11, 6, 6, 16 - distanceFromEdge, 10, 10 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 6, 6, distanceFromEdge, 10, 10, 5 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 6, 6, 11, 10, 10, 16 - distanceFromEdge );
+				break;
+			case UP:
+				cubeBuilder.addCube( 6, 11, 6, 10, 16 - distanceFromEdge, 10 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( distanceFromEdge, 6, 6, 5, 10, 10 );
+				break;
+		}
+	}
+
+	/**
+	 * This renders a slightly bigger covered cable connection to the specified side. This is used to connect cable cores with adjacent machines
+	 * that do not want to be connected to using a glass cable connection. This applies to most machines (interfaces, etc.)
+	 */
+	private void addBigCoveredCableSizedCube( EnumFacing facing, CubeBuilder cubeBuilder )
+	{
+		switch( facing )
+		{
+			case DOWN:
+				cubeBuilder.addCube( 5, 0, 5, 11, 4, 11 );
+				break;
+			case EAST:
+				cubeBuilder.addCube( 12, 5, 5, 16, 11, 11 );
+				break;
+			case NORTH:
+				cubeBuilder.addCube( 5, 5, 0, 11, 11, 4 );
+				break;
+			case SOUTH:
+				cubeBuilder.addCube( 5, 5, 12, 11, 11, 16 );
+				break;
+			case UP:
+				cubeBuilder.addCube( 5, 12, 5, 11, 16, 11 );
+				break;
+			case WEST:
+				cubeBuilder.addCube( 0, 5, 5, 4, 11, 11 );
+				break;
+		}
+	}
+
+	// Get all textures needed for building the actual cable quads
+	public static List<ResourceLocation> getTextures()
+	{
+		List<ResourceLocation> locations = new ArrayList<>();
+
+		for( CableCoreType coreType : CableCoreType.values() )
+		{
+			for( AEColor color : AEColor.values() )
+			{
+				locations.add( coreType.getTexture( color ) );
+			}
+		}
+
+		for( AECableType cableType : AECableType.VALIDCABLES )
+		{
+			for( AEColor color : AEColor.values() )
+			{
+				locations.add( cableType.getConnectionTexture( color ) );
+			}
+		}
+
+		Collections.addAll( locations, SmartCableTextures.SMART_CHANNELS_TEXTURES );
+
+		return locations;
+	}
+
+	public TextureAtlasSprite getCoreTexture( CableCoreType coreType, AEColor color )
+	{
+		return coreTextures.get( coreType ).get( color );
+	}
+
+}

src/main/java/appeng/client/render/cablebus/CableBusBakedModel.java

@@ -0,0 +1,260 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.block.model.ItemCameraTransforms;
+import net.minecraft.client.renderer.block.model.ItemOverrideList;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.property.IExtendedBlockState;
+
+import appeng.api.util.AECableType;
+import appeng.api.util.AEColor;
+import appeng.block.networking.BlockCableBus;
+
+
+public class CableBusBakedModel implements IBakedModel
+{
+
+	private final CableBuilder cableBuilder;
+
+	private final Map<ResourceLocation, IBakedModel> partModels;
+
+	CableBusBakedModel( CableBuilder cableBuilder, Map<ResourceLocation, IBakedModel> partModels )
+	{
+		this.cableBuilder = cableBuilder;
+		this.partModels = partModels;
+	}
+
+	@Override
+	public List<BakedQuad> getQuads( @Nullable IBlockState state, @Nullable EnumFacing side, long rand )
+	{
+		CableBusRenderState renderState = getRenderingState( state );
+
+		if( renderState == null || side != null )
+		{
+			return Collections.emptyList();
+		}
+
+		// First, handle the cable at the center of the cable bus
+		List<BakedQuad> quads = new ArrayList<>();
+		addCableQuads( renderState, quads );
+
+		for( EnumFacing facing : EnumFacing.values() )
+		{
+			List<ResourceLocation> models = renderState.getAttachments().get( facing );
+			if( models == null )
+			{
+				continue;
+			}
+
+			for( ResourceLocation model : models )
+			{
+				IBakedModel bakedModel = partModels.get( model );
+
+				if( bakedModel == null )
+				{
+					throw new IllegalStateException( "Trying to use an unregistered part model: " + model );
+				}
+
+				List<BakedQuad> partQuads = bakedModel.getQuads( state, null, rand );
+
+				// Rotate quads accordingly
+				QuadRotator rotator = new QuadRotator();
+				partQuads = rotator.rotateQuads( partQuads, facing, EnumFacing.UP );
+
+				quads.addAll( partQuads );
+			}
+		}
+
+		return quads;
+	}
+
+
+	// Determines whether a cable is connected to exactly two sides that are opposite each other
+	private static boolean isStraightLine( Set<EnumFacing> sides )
+	{
+		Iterator<EnumFacing> it = sides.iterator();
+		if( !it.hasNext() )
+		{
+			return false; // No connections
+		}
+		EnumFacing firstSide = it.next();
+		if( !it.hasNext() )
+		{
+			return false; // Only a single connection
+		}
+		if( firstSide.getOpposite() != it.next() )
+		{
+			return false; // Connected to two sides that are not opposite each other
+		}
+		return !it.hasNext(); // Must not have any other connection points
+	}
+
+	private void addCableQuads( CableBusRenderState renderState, List<BakedQuad> quadsOut )
+	{
+		AECableType cableType = renderState.getCableType();
+		if( cableType == AECableType.NONE )
+		{
+			return;
+		}
+
+		AEColor cableColor = renderState.getCableColor();
+		EnumMap<EnumFacing, AECableType> connectionTypes = renderState.getConnectionTypes();
+
+		// If the connection is straight, no busses are attached, and no overed core has been forced (in case of glass
+		// cables), then render the cable as a simplified straight line.
+		boolean noAttachments = renderState.getAttachments().isEmpty();
+		if( isStraightLine( connectionTypes.keySet() ) && noAttachments )
+		{
+			EnumFacing facing = connectionTypes.keySet().iterator().next();
+
+			switch (cableType) {
+				case GLASS:
+					cableBuilder.addStraightGlassConnection( facing, cableColor, quadsOut );
+					break;
+				case COVERED:
+					cableBuilder.addStraightCoveredConnection( facing, cableColor, quadsOut );
+					break;
+				case SMART:
+					cableBuilder.addStraightSmartConnection( facing, cableColor, renderState.getChannelsOnSide().get(facing), quadsOut );
+					break;
+				case DENSE:
+					cableBuilder.addStraightDenseConnection( facing, cableColor, renderState.getChannelsOnSide().get(facing), quadsOut );
+					break;
+			}
+
+			return; // Don't render the other form of connection
+		}
+
+		cableBuilder.addCableCore( renderState.getCoreType(), cableColor, quadsOut );
+
+		// Render all internal connections to attachments
+		EnumMap<EnumFacing, Integer> attachmentConnections = renderState.getAttachmentConnections();
+		for( EnumFacing facing : attachmentConnections.keySet() )
+		{
+			int distance = attachmentConnections.get( facing );
+			int channels = renderState.getChannelsOnSide().get( facing );
+
+			switch( cableType )
+			{
+				case GLASS:
+					cableBuilder.addConstrainedGlassConnection( facing, cableColor, distance, quadsOut );
+					break;
+				case COVERED:
+					cableBuilder.addConstrainedCoveredConnection( facing, cableColor, distance, quadsOut );
+					break;
+				case SMART:
+					cableBuilder.addConstrainedSmartConnection( facing, cableColor, distance, channels, quadsOut );
+					break;
+				case DENSE:
+					// Dense cables do not render connections to parts since none can be attached
+					break;
+			}
+		}
+
+		// Render all outgoing connections using the appropriate type
+		for( EnumFacing facing : connectionTypes.keySet() )
+		{
+			AECableType connectionType = connectionTypes.get( facing );
+			boolean cableBusAdjacent = renderState.getCableBusAdjacent().contains( facing );
+			int channels = renderState.getChannelsOnSide().get( facing );
+
+			switch( cableType )
+			{
+				case GLASS:
+					cableBuilder.addGlassConnection( facing, cableColor, connectionType, cableBusAdjacent, quadsOut );
+					break;
+				case COVERED:
+					cableBuilder.addCoveredConnection( facing, cableColor, connectionType, cableBusAdjacent, quadsOut );
+					break;
+				case SMART:
+					cableBuilder.addSmartConnection( facing, cableColor, connectionType, cableBusAdjacent, channels, quadsOut );
+					break;
+				case DENSE:
+					cableBuilder.addDenseConnection( facing, cableColor, connectionType, cableBusAdjacent, channels, quadsOut );
+					break;
+			}
+		}
+	}
+
+	/**
+	 * Gets a list of texture sprites appropriate for particles (digging, etc.) given the render state for a cable bus.
+	 */
+	public List<TextureAtlasSprite> getParticleTextures( CableBusRenderState renderState )
+	{
+		CableCoreType coreType = renderState.getCableType().getCoreType();
+		AEColor cableColor = renderState.getCableColor();
+
+		if( coreType != null )
+		{
+			return Collections.singletonList( cableBuilder.getCoreTexture( coreType, cableColor ) );
+		}
+		else
+		{
+			return Collections.emptyList();
+		}
+
+		// TODO: Add break particles even for the attachments, not just the cable
+
+	}
+
+	private static CableBusRenderState getRenderingState( IBlockState state )
+	{
+		if( state == null || !( state instanceof IExtendedBlockState ) )
+		{
+			return null;
+		}
+
+		IExtendedBlockState extendedBlockState = (IExtendedBlockState) state;
+		return extendedBlockState.getValue( BlockCableBus.RENDER_STATE_PROPERTY );
+	}
+
+	@Override
+	public boolean isAmbientOcclusion()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isGui3d()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isBuiltInRenderer()
+	{
+		return false;
+	}
+
+	@Override
+	public TextureAtlasSprite getParticleTexture()
+	{
+		return null;
+	}
+
+	@Override
+	public ItemCameraTransforms getItemCameraTransforms()
+	{
+		return ItemCameraTransforms.DEFAULT;
+	}
+
+	@Override
+	public ItemOverrideList getOverrides()
+	{
+		return ItemOverrideList.NONE;
+	}
+}

src/main/java/appeng/client/render/cablebus/CableBusModel.java

@@ -0,0 +1,94 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.Collection;
+import java.util.Map;
+
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableMap;
+
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.IModel;
+import net.minecraftforge.client.model.ModelLoaderRegistry;
+import net.minecraftforge.common.model.IModelState;
+import net.minecraftforge.common.model.TRSRTransformation;
+
+import appeng.core.AELog;
+import appeng.core.features.registries.PartModels;
+
+
+/**
+ * The built-in model for the cable bus block.
+ */
+public class CableBusModel implements IModel
+{
+
+	private final PartModels partModels;
+
+	public CableBusModel( PartModels partModels )
+	{
+		this.partModels = partModels;
+	}
+
+	@Override
+	public Collection<ResourceLocation> getDependencies()
+	{
+		partModels.setInitialized( true );
+		return partModels.getModels();
+	}
+
+	@Override
+	public Collection<ResourceLocation> getTextures()
+	{
+		return CableBuilder.getTextures();
+	}
+
+	@Override
+	public IBakedModel bake( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+	{
+
+		Map<ResourceLocation, IBakedModel> partModels = loadPartModels( state, format, bakedTextureGetter );
+
+		CableBuilder cableBuilder = new CableBuilder( format, bakedTextureGetter );
+		return new CableBusBakedModel( cableBuilder, partModels );
+	}
+
+	private Map<ResourceLocation, IBakedModel> loadPartModels(
+			IModelState state,
+			VertexFormat format,
+			Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+	{
+		ImmutableMap.Builder<ResourceLocation, IBakedModel> result = ImmutableMap.builder();
+
+		for( ResourceLocation location : partModels.getModels() )
+		{
+			IModel model = tryLoadPartModel( location );
+			IBakedModel bakedModel = model.bake( state, format, bakedTextureGetter );
+			result.put( location, bakedModel );
+		}
+
+		return result.build();
+	}
+
+	private IModel tryLoadPartModel( ResourceLocation location )
+	{
+		try
+		{
+			return ModelLoaderRegistry.getModel( location );
+		}
+		catch( Exception e )
+		{
+			AELog.error( e, "Unable to load part model " + location );
+			return ModelLoaderRegistry.getMissingModel();
+		}
+	}
+
+	@Override
+	public IModelState getDefaultState()
+	{
+		return TRSRTransformation.identity();
+	}
+}

src/main/java/appeng/client/render/cablebus/CableBusRenderState.java

@@ -0,0 +1,116 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+
+import appeng.api.util.AECableType;
+import appeng.api.util.AEColor;
+
+
+/**
+ * This class captures the entire rendering state needed for a cable bus and transports it to the rendering thread
+ * for processing.
+ */
+public class CableBusRenderState
+{
+
+	// The cable type used for rendering the outgoing connections to other blocks and attached parts
+	private AECableType cableType = AECableType.NONE;
+
+	// The type to use for rendering the core of the cable.
+	private CableCoreType coreType;
+
+	private AEColor cableColor = AEColor.Transparent;
+
+	// Describes the outgoing connections of this cable bus to other blocks, and how they should be rendered
+	private EnumMap<EnumFacing, AECableType> connectionTypes = new EnumMap<>( EnumFacing.class );
+
+	// Indicate on which sides signified by connectionTypes above, there is another cable bus. If a side is connected, but it is absent from this
+	// set, then it means that there is a Grid host, but not a cable bus on that side (i.e. an interface, a controller, etc.)
+	private EnumSet<EnumFacing> cableBusAdjacent = EnumSet.noneOf( EnumFacing.class );
+
+	// Specifies the number of channels used for the connection to a given side. Only contains entries if
+	// connections contains a corresponding entry.
+	private EnumMap<EnumFacing, Integer> channelsOnSide = new EnumMap<>( EnumFacing.class );
+
+	private EnumMap<EnumFacing, List<ResourceLocation>> attachments = new EnumMap<>( EnumFacing.class );
+
+	// For each attachment, this contains the distance from the edge until which a cable connection should be drawn
+	private EnumMap<EnumFacing, Integer> attachmentConnections = new EnumMap<>( EnumFacing.class );
+
+	public CableCoreType getCoreType()
+	{
+		return coreType;
+	}
+
+	public void setCoreType( CableCoreType coreType )
+	{
+		this.coreType = coreType;
+	}
+
+	public AECableType getCableType()
+	{
+		return cableType;
+	}
+
+	public void setCableType( AECableType cableType )
+	{
+		this.cableType = cableType;
+	}
+
+	public AEColor getCableColor()
+	{
+		return cableColor;
+	}
+
+	public void setCableColor( AEColor cableColor )
+	{
+		this.cableColor = cableColor;
+	}
+
+	public EnumMap<EnumFacing, Integer> getChannelsOnSide()
+	{
+		return channelsOnSide;
+	}
+
+	public EnumMap<EnumFacing, AECableType> getConnectionTypes()
+	{
+		return connectionTypes;
+	}
+
+	public void setConnectionTypes( EnumMap<EnumFacing, AECableType> connectionTypes )
+	{
+		this.connectionTypes = connectionTypes;
+	}
+
+	public void setChannelsOnSide( EnumMap<EnumFacing, Integer> channelsOnSide )
+	{
+		this.channelsOnSide = channelsOnSide;
+	}
+
+	public EnumSet<EnumFacing> getCableBusAdjacent()
+	{
+		return cableBusAdjacent;
+	}
+
+	public void setCableBusAdjacent( EnumSet<EnumFacing> cableBusAdjacent )
+	{
+		this.cableBusAdjacent = cableBusAdjacent;
+	}
+
+	public EnumMap<EnumFacing, List<ResourceLocation>> getAttachments()
+	{
+		return attachments;
+	}
+
+	public EnumMap<EnumFacing, Integer> getAttachmentConnections()
+	{
+		return attachmentConnections;
+	}
+
+}

src/main/java/appeng/client/render/cablebus/CableCoreType.java

@@ -0,0 +1,35 @@
+package appeng.client.render.cablebus;
+
+
+import net.minecraft.util.ResourceLocation;
+
+import appeng.api.util.AEColor;
+import appeng.core.AppEng;
+
+
+/**
+ * AE can render the core of a cable (the core that connections are made to, in case the cable is not a straight line)
+ * in three different ways:
+ * - Glass
+ * - Covered (also used by the Smart Cable)
+ * - Dense
+ */
+public enum CableCoreType
+{
+	GLASS( "parts/cable/core/glass" ),
+	COVERED( "parts/cable/core/covered" ),
+	DENSE( "parts/cable/core/dense" );
+
+	private final String textureFolder;
+
+	CableCoreType( String textureFolder )
+	{
+		this.textureFolder = textureFolder;
+	}
+
+	public ResourceLocation getTexture( AEColor color )
+	{
+		return new ResourceLocation( AppEng.MOD_ID, textureFolder + "/" + color.name().toLowerCase() );
+	}
+
+}

src/main/java/appeng/client/render/cablebus/CubeBuilder.java

@@ -0,0 +1,275 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+import javax.vecmath.Vector4f;
+
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.client.renderer.vertex.VertexFormatElement;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.client.model.pipeline.UnpackedBakedQuad;
+
+
+/**
+ * Builds the quads for a cube.
+ */
+public class CubeBuilder {
+
+    private VertexFormat format;
+
+    private final List<BakedQuad> output;
+
+    private final EnumMap<EnumFacing, TextureAtlasSprite> textures = new EnumMap<>(EnumFacing.class);
+
+    private EnumSet<EnumFacing> drawFaces = EnumSet.allOf(EnumFacing.class);
+
+    private final EnumMap<EnumFacing, Vector4f> customUv = new EnumMap<>(EnumFacing.class);
+
+    private int color = 0xFFFFFFFF;
+
+    private boolean renderFullBright;
+
+    public CubeBuilder(VertexFormat format, List<BakedQuad> output) {
+        this.output = output;
+        this.format = format;
+    }
+
+    public CubeBuilder(VertexFormat format) {
+        this(format, new ArrayList<>(6));
+    }
+
+    public void addCube(float x1, float y1, float z1, float x2, float y2, float z2) {
+        x1 /= 16.0f;
+        y1 /= 16.0f;
+        z1 /= 16.0f;
+        x2 /= 16.0f;
+        y2 /= 16.0f;
+        z2 /= 16.0f;
+
+        // If brightness is forced to specific values, extend the vertex format to contain the multi-texturing lightmap offset
+        VertexFormat savedFormat = null;
+        if (renderFullBright) {
+            savedFormat = format;
+            format = new VertexFormat(savedFormat);
+            if (!format.getElements().contains(DefaultVertexFormats.TEX_2S)) {
+                format.addElement(DefaultVertexFormats.TEX_2S);
+            }
+        }
+
+        for (EnumFacing face : drawFaces) {
+            putFace(face, x1, y1, z1, x2, y2, z2);
+        }
+
+        // Restore old format
+        if (savedFormat != null) {
+            format = savedFormat;
+        }
+    }
+
+    private void putFace(EnumFacing face,
+                         float x1, float y1, float z1,
+                         float x2, float y2, float z2
+    ) {
+
+        TextureAtlasSprite texture = textures.get(face);
+
+        UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
+        builder.setTexture(texture);
+        builder.setQuadOrientation(face);
+
+        float u1 = 0;
+        float v1 = 0;
+        float u2 = 0;
+        float v2 = 0;
+
+        // The user might have set specific UV coordinates for this face
+        Vector4f customUv = this.customUv.get( face );
+        if( customUv != null )
+        {
+            u1 = texture.getInterpolatedU( customUv.x );
+            v1 = texture.getInterpolatedV( customUv.y );
+            u2 = texture.getInterpolatedU( customUv.z );
+            v2 = texture.getInterpolatedV( customUv.w );
+        }
+
+        switch (face) {
+            case DOWN:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( x1 * 16 );
+                    v1 = texture.getInterpolatedV( z1 * 16 );
+                    u2 = texture.getInterpolatedU( x2 * 16 );
+                    v2 = texture.getInterpolatedV( z2 * 16 );
+                }
+
+                putVertex(builder, face, x2, y1, z1, u2, v1);
+                putVertex(builder, face, x2, y1, z2, u2, v2);
+                putVertex(builder, face, x1, y1, z2, u1, v2);
+                putVertex(builder, face, x1, y1, z1, u1, v1);
+                break;
+            case UP:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( x1 * 16 );
+                    v1 = texture.getInterpolatedV( z1 * 16 );
+                    u2 = texture.getInterpolatedU( x2 * 16 );
+                    v2 = texture.getInterpolatedV( z2 * 16 );
+                }
+
+                putVertex(builder, face, x1, y2, z1, u1, v1);
+                putVertex(builder, face, x1, y2, z2, u1, v2);
+                putVertex(builder, face, x2, y2, z2, u2, v2);
+                putVertex(builder, face, x2, y2, z1, u2, v1);
+                break;
+            case NORTH:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( x1 * 16 );
+                    v1 = texture.getInterpolatedV( 16 - y1 * 16 );
+                    u2 = texture.getInterpolatedU( x2 * 16 );
+                    v2 = texture.getInterpolatedV( 16 - y2 * 16 );
+                }
+
+                putVertex(builder, face, x2, y2, z1, u1, v2);
+                putVertex(builder, face, x2, y1, z1, u1, v1);
+                putVertex(builder, face, x1, y1, z1, u2, v1);
+                putVertex(builder, face, x1, y2, z1, u2, v2);
+                break;
+            case SOUTH:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( x1 * 16 );
+                    v1 = texture.getInterpolatedV( 16 - y1 * 16 );
+                    u2 = texture.getInterpolatedU( x2 * 16 );
+                    v2 = texture.getInterpolatedV( 16 - y2 * 16 );
+                }
+
+                putVertex(builder, face, x1, y2, z2, u1, v2);
+                putVertex(builder, face, x1, y1, z2, u1, v1);
+                putVertex(builder, face, x2, y1, z2, u2, v1);
+                putVertex(builder, face, x2, y2, z2, u2, v2);
+                break;
+            case WEST:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( z1 * 16 );
+                    v1 = texture.getInterpolatedV( 16 - y1 * 16 );
+                    u2 = texture.getInterpolatedU( z2 * 16 );
+                    v2 = texture.getInterpolatedV( 16 - y2 * 16 );
+                }
+
+                putVertex(builder, face, x1, y1, z1, u1, v1);
+                putVertex(builder, face, x1, y1, z2, u2, v1);
+                putVertex(builder, face, x1, y2, z2, u2, v2);
+                putVertex(builder, face, x1, y2, z1, u1, v2);
+                break;
+            case EAST:
+                if (customUv == null)
+                {
+                    u1 = texture.getInterpolatedU( z2 * 16 );
+                    v1 = texture.getInterpolatedV( 16 - y1 * 16 );
+                    u2 = texture.getInterpolatedU( z1 * 16 );
+                    v2 = texture.getInterpolatedV( 16 - y2 * 16 );
+                }
+
+                putVertex(builder, face, x2, y2, z1, u1, v2);
+                putVertex(builder, face, x2, y2, z2, u2, v2);
+                putVertex(builder, face, x2, y1, z2, u2, v1);
+                putVertex(builder, face, x2, y1, z1, u1, v1);
+                break;
+        }
+
+        int[] vertexData = builder.build().getVertexData();
+        output.add(new BakedQuad(vertexData, -1, face, texture, true, format));
+    }
+
+    private void putVertex(UnpackedBakedQuad.Builder builder, EnumFacing face, float x, float y, float z, float u, float v) {
+        VertexFormat format = builder.getVertexFormat();
+
+        for (int i = 0; i < format.getElementCount(); i++) {
+            VertexFormatElement e = format.getElement(i);
+            switch (e.getUsage()) {
+                case POSITION:
+                    builder.put(i, x, y, z);
+                    break;
+                case NORMAL:
+                    builder.put(i,
+                            face.getFrontOffsetX(),
+                            face.getFrontOffsetY(),
+                            face.getFrontOffsetZ());
+                    break;
+                case COLOR:
+                    // Color format is RGBA
+                    float r = (color >> 16 & 0xFF) / 255f;
+                    float g = (color >> 8 & 0xFF) / 255f;
+                    float b = (color & 0xFF) / 255f;
+                    float a = (color >> 24 & 0xFF) / 255f;
+                    builder.put(i, r, g, b, a);
+                    break;
+                case UV:
+                    if (e.getIndex() == 0) {
+                        builder.put(i, u, v);
+                    } else {
+                        // Force Brightness to 15, this is for full bright mode
+                        // this vertex element will only be present in that case
+                        final float lightMapU = (float) (15 * 0x20) / 0xFFFF;
+                        final float lightMapV = (float) (15 * 0x20) / 0xFFFF;
+                        builder.put(i, lightMapU, lightMapV);
+                    }
+                    break;
+                default:
+                    builder.put(i);
+                    break;
+            }
+        }
+    }
+
+    public void setTexture(TextureAtlasSprite texture) {
+        for (EnumFacing face : EnumFacing.values()) {
+            textures.put(face, texture);
+        }
+    }
+
+    public void setTextures(TextureAtlasSprite up, TextureAtlasSprite down, TextureAtlasSprite north, TextureAtlasSprite south, TextureAtlasSprite east, TextureAtlasSprite west) {
+        textures.put(EnumFacing.UP, up);
+        textures.put(EnumFacing.DOWN, down);
+        textures.put(EnumFacing.NORTH, north);
+        textures.put(EnumFacing.SOUTH, south);
+        textures.put(EnumFacing.EAST, east);
+        textures.put(EnumFacing.WEST, west);
+    }
+
+    public void setDrawFaces(EnumSet<EnumFacing> drawFaces) {
+        this.drawFaces = drawFaces;
+    }
+
+    public void setColor(int color) {
+        this.color = color;
+    }
+
+    /**
+     * Sets the vertex color for future vertices to the given RGB value, and forces the alpha component to 255.
+     */
+    public void setColorRGB(int color) {
+        setColor(color | 0xFF000000);
+    }
+
+    public void setRenderFullBright(boolean renderFullBright) {
+        this.renderFullBright = renderFullBright;
+    }
+
+    public void setCustomUv( EnumFacing facing, float u1, float v1, float u2, float v2 )
+    {
+        customUv.put( facing, new Vector4f( u1, v1, u2, v2 ) );
+    }
+
+    public List<BakedQuad> getOutput() {
+        return output;
+    }
+}

src/main/java/appeng/client/render/cablebus/QuadRotator.java

@@ -0,0 +1,169 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.vecmath.Matrix4f;
+import javax.vecmath.Point3f;
+import javax.vecmath.Vector3f;
+
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.client.renderer.vertex.VertexFormatElement;
+import net.minecraft.util.EnumFacing;
+
+import appeng.client.render.FacingToRotation;
+import appeng.core.AELog;
+
+
+/**
+ * Assuming a default-orientation of forward=NORTH and up=UP, this class rotates a given list of quads to the desired facing
+ */
+public class QuadRotator
+{
+
+	public List<BakedQuad> rotateQuads( List<BakedQuad> quads, EnumFacing newForward, EnumFacing newUp )
+	{
+		if( newForward == EnumFacing.NORTH && newUp == EnumFacing.UP )
+		{
+			return quads; // This is the default orientation
+		}
+
+		List<BakedQuad> result = new ArrayList<>( quads.size() );
+
+		for( BakedQuad quad : quads )
+		{
+			result.add( rotateQuad( quad, newForward, newUp ) );
+		}
+
+		return result;
+	}
+
+	private BakedQuad rotateQuad( BakedQuad quad, EnumFacing forward, EnumFacing up )
+	{
+		// Sanitize forward/up
+		if (forward.getAxis() == up.getAxis()) {
+			if (up.getAxis() == EnumFacing.Axis.Y) {
+				up = EnumFacing.NORTH;
+			} else {
+				up = EnumFacing.UP;
+			}
+		}
+
+		FacingToRotation rotation = FacingToRotation.get( forward, up );
+		Matrix4f mat = rotation.getMat();
+
+		// Clone the vertex data used by the quad
+		int[] newData = quad.getVertexData().clone();
+
+		// Figure out where the position is in the array
+		VertexFormat format = quad.getFormat();
+		int posIdx = findPositionOffset( format ) / 4;
+		int stride = format.getNextOffset() / 4;
+		int normalIdx = format.getNormalOffset();
+		VertexFormatElement.EnumType normalType = null;
+		// Figure out the type of the normals
+		if( normalIdx != -1 )
+		{
+			for( int i = 0; i < format.getElements().size(); i++ )
+			{
+				VertexFormatElement element = format.getElement( i );
+				if( element.getUsage() == VertexFormatElement.EnumUsage.NORMAL )
+				{
+					normalType = element.getType();
+				}
+			}
+		}
+
+		for( int i = 0; i < 4; i++ )
+		{
+			Point3f pos = new Point3f(
+					Float.intBitsToFloat( newData[i * stride + posIdx] ) - 0.5f,
+					Float.intBitsToFloat( newData[i * stride + posIdx + 1] ) - 0.5f,
+					Float.intBitsToFloat( newData[i * stride + posIdx + 2] ) - 0.5f
+			);
+
+			// Rotate stuff around
+			mat.transform( pos );
+
+			// Write back
+			newData[i * stride + posIdx] = Float.floatToIntBits( pos.getX() + 0.5f );
+			newData[i * stride + posIdx + 1] = Float.floatToIntBits( pos.getY() + 0.5f );
+			newData[i * stride + posIdx + 2] = Float.floatToIntBits( pos.getZ() + 0.5f );
+
+			// Transform the normal if one is present
+			if ( normalIdx != -1 ) {
+				if( normalType == VertexFormatElement.EnumType.FLOAT )
+				{
+					Vector3f normal = new Vector3f(
+							Float.intBitsToFloat( newData[i * stride + normalIdx] ),
+							Float.intBitsToFloat( newData[i * stride + normalIdx + 1] ),
+							Float.intBitsToFloat( newData[i * stride + normalIdx + 2] )
+					);
+
+					// Rotate stuff around
+					mat.transform( normal );
+
+					// Write back
+					newData[i * stride + normalIdx] = Float.floatToIntBits( normal.getX() );
+					newData[i * stride + normalIdx + 1] = Float.floatToIntBits( normal.getY() );
+					newData[i * stride + normalIdx + 2] = Float.floatToIntBits( normal.getZ() );
+				}
+				else if( normalType == VertexFormatElement.EnumType.BYTE )
+				{
+					int idx = i * stride * 4 + normalIdx;
+					Vector3f normal = new Vector3f( getByte( newData, idx ) / 127.0f, getByte( newData, idx + 1 ) / 127.0f, getByte( newData, idx + 2 ) / 127.0f );
+
+					// Rotate stuff around
+					mat.transform( normal );
+
+					// Write back
+					setByte( newData, idx, (int) ( normal.getX() * 127 ) );
+					setByte( newData, idx + 1, (int) ( normal.getY() * 127 ) );
+					setByte( newData, idx + 2, (int) ( normal.getZ() * 127 ) );
+				}
+				else
+				{
+					AELog.warn( "Unsupported normal format: {}", normalType );
+				}
+			}
+		}
+
+		EnumFacing newFace = rotation.rotate( quad.getFace() );
+		return new BakedQuad( newData, quad.getTintIndex(), newFace, quad.getSprite(), quad.shouldApplyDiffuseLighting(), quad.getFormat() );
+	}
+
+	private static int getByte( int[] data, int offset )
+	{
+		int idx = offset / 4;
+		int subOffset = offset % 4;
+		return (byte) ( data[idx] >> ( subOffset * 8 ) );
+	}
+
+	private static void setByte( int[] data, int offset, int value )
+	{
+		int idx = offset / 4;
+		int subOffset = offset % 4;
+		int mask = 0xFF << ( subOffset * 8 );
+		data[idx] = data[idx] & ( ~mask ) | ( (value & 0xFF) << (subOffset * 8) );
+	}
+
+	private int findPositionOffset( VertexFormat format )
+	{
+		List<VertexFormatElement> elements = format.getElements();
+		for( int i = 0; i < elements.size(); i++ )
+		{
+			VertexFormatElement e = elements.get( i );
+			if( e.isPositionElement() )
+			{
+				if( e.getType() != VertexFormatElement.EnumType.FLOAT )
+				{
+					throw new IllegalArgumentException( "Only floating point positions are supported" );
+				}
+				return i;
+			}
+		}
+
+		throw new IllegalArgumentException( "Vertex format " + format + " has no position attribute!" );
+	}
+}

src/main/java/appeng/client/render/cablebus/SmartCableTextures.java

@@ -0,0 +1,81 @@
+package appeng.client.render.cablebus;
+
+
+import java.util.Arrays;
+
+import com.google.common.base.Function;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.ResourceLocation;
+
+import appeng.core.AppEng;
+
+
+/**
+ * Manages the channel textures for smart cables.
+ */
+public class SmartCableTextures
+{
+
+	public static final ResourceLocation[] SMART_CHANNELS_TEXTURES = {
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_00" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_01" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_02" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_03" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_04" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_10" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_11" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_12" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_13" ),
+			new ResourceLocation( AppEng.MOD_ID, "parts/cable/smart/channels_14" )
+	};
+
+	// Textures used to display channels on smart cables. There's two sets of 5 textures each, and
+	// one of each set are composed together to get even/odd colored channels
+	private final TextureAtlasSprite[] textures;
+
+	public SmartCableTextures( Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+	{
+		textures = Arrays.stream( SMART_CHANNELS_TEXTURES )
+				.map( bakedTextureGetter::apply )
+				.toArray( TextureAtlasSprite[]::new );
+	}
+
+	/**
+	 * The odd variant is used for displaying channels 1-4 as in use.
+	 */
+	public TextureAtlasSprite getOddTextureForChannels( int channels )
+	{
+		if( channels < 0 )
+		{
+			return textures[0];
+		}
+		else if( channels <= 4 )
+		{
+			return textures[channels];
+		}
+		else
+		{
+			return textures[4];
+		}
+	}
+
+	/**
+	 * The odd variant is used for displaying channels 5-8 as in use.
+	 */
+	public TextureAtlasSprite getEvenTextureForChannels( int channels )
+	{
+		if( channels < 5 )
+		{
+			return textures[5];
+		}
+		else if( channels <= 9 )
+		{
+			return textures[channels];
+		}
+		else
+		{
+			return textures[9];
+		}
+	}
+}