feat: add legacy models

src/main/java/mekanism/api/MekanismConfig.java

@@ -88,6 +88,7 @@ public class MekanismConfig {
         public static boolean opaqueTransmitters = false;
         public static boolean doMultiblockSparkle = true;
         public static int multiblockSparkleIntensity = 6;
+        public static ModelType modelType = ModelType.LEGACY;
     }
 
     public static class machines {

src/main/java/mekanism/api/ModelType.java

@@ -0,0 +1,68 @@
+package mekanism.api;
+
+import java.util.function.Supplier;
+
+import mekanism.client.IModelMekanism;
+
+public enum ModelType {
+    MODERN,
+    LEGACY,
+    CLASSIC;
+
+    public static ModelType fromString(String s) {
+        if (s.equalsIgnoreCase("modern"))
+            return MODERN;
+
+        if (s.equalsIgnoreCase("legacy"))
+            return LEGACY;
+
+        if (s.equalsIgnoreCase("classic"))
+            return CLASSIC;
+
+        return null;
+    }
+
+    public boolean isOld() {
+        return this != MODERN;
+    }
+
+    public <T extends IModelMekanism> T createModel(
+        Supplier<? extends T> modern,
+        Supplier<? extends T> legacy,
+        Supplier<? extends T> classic
+    ) {
+        switch (this) {
+            case MODERN:
+                return modern.get();
+            case LEGACY:
+                return legacy.get();
+            case CLASSIC:
+                return classic.get();
+            default:
+                throw new RuntimeException("ALECUS MAXIMUS");
+        }
+    }
+
+    public <T extends IModelMekanism>
+        T createModel(Supplier<? extends T> modern, Supplier<? extends T> legacy) {
+        return this.createModel(modern, legacy, legacy);
+    }
+
+    public int mapFacing(int facing) {
+        if (!this.isOld())
+            return facing;
+
+        switch (facing) {
+            case 2:
+                return 3;
+            case 3:
+                return 2;
+            case 4:
+                return 5;
+            case 5:
+                return 4;
+        }
+
+        return -1;
+    }
+}

src/main/java/mekanism/client/ClientProxy.java

@@ -15,6 +15,7 @@ import cpw.mods.fml.relauncher.SideOnly;
 import mekanism.api.Coord4D;
 import mekanism.api.MekanismConfig.client;
 import mekanism.api.MekanismConfig.general;
+import mekanism.api.ModelType;
 import mekanism.api.Pos3D;
 import mekanism.client.SparkleAnimation.INodeChecker;
 import mekanism.client.entity.EntityLaser;
@@ -264,6 +265,14 @@ public class ClientProxy extends CommonProxy {
             = Mekanism.configuration.get("client", "MultiblockSparkleIntesity", 6)
                   .getInt();
 
+        ModelType modelType = ModelType.fromString(
+            Mekanism.configuration.get("client", "ModelType", "LEGACY").getString()
+        );
+
+        if (modelType != null) {
+            client.modelType = modelType;
+        }
+
         if (Mekanism.configuration.hasChanged()) {
             Mekanism.configuration.save();
         }

src/main/java/mekanism/client/IModelMekanism.java

@@ -0,0 +1,6 @@
+package mekanism.client;
+
+public interface IModelMekanism {
+    String getTextureName();
+    void render(float size);
+}

src/main/java/mekanism/client/ModelMekanismBase.java

@@ -0,0 +1,10 @@
+package mekanism.client;
+
+import net.minecraft.client.model.ModelBase;
+
+/**
+ * ModelMekanismBase
+ *
+ * Abstract class with a render method that takes only a size paramter.
+ */
+public abstract class ModelMekanismBase extends ModelBase implements IModelMekanism {}

src/main/java/mekanism/client/model/IModelEnergyCube.java

@@ -0,0 +1,16 @@
+package mekanism.client.model;
+
+import mekanism.common.SideData.IOState;
+import mekanism.common.Tier.EnergyCubeTier;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IModelEnergyCube extends IModelTier {
+    void renderSide(
+        float size,
+        ForgeDirection side,
+        IOState state,
+        EnergyCubeTier tier,
+        TextureManager renderer
+    );
+}

src/main/java/mekanism/client/model/IModelGlass.java

@@ -0,0 +1,7 @@
+package mekanism.client.model;
+
+import mekanism.client.IModelMekanism;
+
+public interface IModelGlass extends IModelMekanism {
+    void renderGlass(float size);
+}

src/main/java/mekanism/client/model/IModelOnOff.java

@@ -0,0 +1,14 @@
+package mekanism.client.model;
+
+import mekanism.client.IModelMekanism;
+import net.minecraft.client.renderer.texture.TextureManager;
+
+public interface IModelOnOff extends IModelMekanism {
+    default void render(float size, boolean on, TextureManager manager) {
+        this.render(size);
+    }
+
+    default String getTextureNameForState(boolean on) {
+        return this.getTextureName();
+    }
+}

src/main/java/mekanism/client/model/IModelSeismicVibrator.java

@@ -0,0 +1,5 @@
+package mekanism.client.model;
+
+public interface IModelSeismicVibrator extends IModelOnOff {
+    void renderWithPiston(float piston, float size);
+}

src/main/java/mekanism/client/model/IModelTier.java

@@ -0,0 +1,12 @@
+package mekanism.client.model;
+
+import mekanism.client.IModelMekanism;
+import mekanism.common.Tier.BaseTier;
+import net.minecraft.client.renderer.texture.TextureManager;
+
+public interface IModelTier extends IModelMekanism {
+    String getTextureNameForTier(BaseTier tier);
+    default void render(float size, BaseTier tier, TextureManager manager) {
+        this.render(size);
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChargepad.java

@@ -0,0 +1,68 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelChargepad extends ModelMekanismBase {
+    ModelRenderer Shape1;
+    ModelRenderer Shape2;
+    ModelRenderer Shape3;
+    ModelRenderer Shape4;
+    ModelRenderer Shape5;
+
+    public LegacyModelChargepad() {
+        textureWidth = 64;
+        textureHeight = 64;
+
+        Shape1 = new ModelRenderer(this, 0, 0);
+        Shape1.addBox(0F, 0F, 0F, 16, 1, 16);
+        Shape1.setRotationPoint(-8F, 23F, -8F);
+        Shape1.setTextureSize(64, 64);
+        Shape1.mirror = true;
+        setRotation(Shape1, 0F, 0F, 0F);
+        Shape2 = new ModelRenderer(this, 0, 18);
+        Shape2.addBox(0F, 0F, 0F, 8, 11, 2);
+        Shape2.setRotationPoint(-4F, 12F, 6F);
+        Shape2.setTextureSize(64, 64);
+        Shape2.mirror = true;
+        setRotation(Shape2, 0F, 0F, 0F);
+        Shape3 = new ModelRenderer(this, 0, 0);
+        Shape3.addBox(0F, 0F, 0F, 4, 3, 1);
+        Shape3.setRotationPoint(-2F, 14F, 5F);
+        Shape3.setTextureSize(64, 64);
+        Shape3.mirror = true;
+        setRotation(Shape3, 0F, 0F, 0F);
+        Shape4 = new ModelRenderer(this, 3, 8);
+        Shape4.addBox(0F, 0F, 0F, 2, 5, 2);
+        Shape4.setRotationPoint(-5F, 18F, 5F);
+        Shape4.setTextureSize(64, 64);
+        Shape4.mirror = true;
+        setRotation(Shape4, 0F, 0F, 0F);
+        Shape5 = new ModelRenderer(this, 3, 8);
+        Shape5.addBox(0F, 0F, 0F, 2, 5, 2);
+        Shape5.setRotationPoint(3F, 18F, 5F);
+        Shape5.setTextureSize(64, 64);
+        Shape5.mirror = true;
+        setRotation(Shape5, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Shape1.render(size);
+        Shape2.render(size);
+        Shape3.render(size);
+        Shape4.render(size);
+        Shape5.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChargepad.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChemicalCrystallizer.java

@@ -0,0 +1,325 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelChemicalCrystallizer extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer IO1;
+    ModelRenderer IO2;
+    ModelRenderer Base3;
+    ModelRenderer Base2;
+    ModelRenderer Can1B;
+    ModelRenderer Can1T;
+    ModelRenderer Can1Side3;
+    ModelRenderer Can1Side1;
+    ModelRenderer Can1Side2;
+    ModelRenderer Can1Side4;
+    ModelRenderer Can2Side4;
+    ModelRenderer Can3Side3;
+    ModelRenderer Can2Side2;
+    ModelRenderer Can2Side3;
+    ModelRenderer Can2Side1;
+    ModelRenderer Can4Side3;
+    ModelRenderer Can4Side1;
+    ModelRenderer Can4Sjde4;
+    ModelRenderer Can4Side2;
+    ModelRenderer Can3Side4;
+    ModelRenderer Can4B;
+    ModelRenderer Can3Side2;
+    ModelRenderer Can3Side1;
+    ModelRenderer Can2B;
+    ModelRenderer Can4T;
+    ModelRenderer Can2T;
+    ModelRenderer Can3T;
+    ModelRenderer Can3B;
+    ModelRenderer Spire;
+    ModelRenderer Spin;
+    ModelRenderer Vial1;
+    ModelRenderer Vial2;
+    ModelRenderer Vial3;
+    ModelRenderer Vial4;
+
+    public LegacyModelChemicalCrystallizer() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        Base = new ModelRenderer(this, 16, 0);
+        Base.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base.setRotationPoint(-7F, 23F, -7F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        IO1 = new ModelRenderer(this, 9, 17);
+        IO1.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO1.setRotationPoint(-8F, 12F, -4F);
+        IO1.setTextureSize(128, 64);
+        IO1.mirror = true;
+        setRotation(IO1, 0F, 0F, 0F);
+        IO2 = new ModelRenderer(this, 9, 17);
+        IO2.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO2.setRotationPoint(7F, 12F, -4F);
+        IO2.setTextureSize(128, 64);
+        IO2.mirror = true;
+        setRotation(IO2, 0F, 0F, 0F);
+        Base3 = new ModelRenderer(this, 16, 0);
+        Base3.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base3.setRotationPoint(-7F, 9F, -7F);
+        Base3.setTextureSize(128, 64);
+        Base3.mirror = true;
+        setRotation(Base3, 0F, 0F, 0F);
+        Base2 = new ModelRenderer(this, 16, 0);
+        Base2.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base2.setRotationPoint(-7F, 14F, -7F);
+        Base2.setTextureSize(128, 64);
+        Base2.mirror = true;
+        setRotation(Base2, 0F, 0F, 0F);
+        Can1B = new ModelRenderer(this, 0, 0);
+        Can1B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1B.setRotationPoint(2F, 13F, 2F);
+        Can1B.setTextureSize(128, 64);
+        Can1B.mirror = true;
+        setRotation(Can1B, 0F, 0F, 0F);
+        Can1T = new ModelRenderer(this, 0, 0);
+        Can1T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1T.setRotationPoint(2F, 10F, 2F);
+        Can1T.setTextureSize(128, 64);
+        Can1T.mirror = true;
+        setRotation(Can1T, 0F, 0F, 0F);
+        Can1Side3 = new ModelRenderer(this, 0, 0);
+        Can1Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can1Side3.setRotationPoint(5F, 11F, 3F);
+        Can1Side3.setTextureSize(128, 64);
+        Can1Side3.mirror = true;
+        setRotation(Can1Side3, 0F, 0F, 0F);
+        Can1Side1 = new ModelRenderer(this, 0, 0);
+        Can1Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can1Side1.setRotationPoint(2F, 11F, 5F);
+        Can1Side1.setTextureSize(128, 64);
+        Can1Side1.mirror = true;
+        setRotation(Can1Side1, 0F, 0F, 0F);
+        Can1Side2 = new ModelRenderer(this, 0, 0);
+        Can1Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can1Side2.setRotationPoint(2F, 11F, 2F);
+        Can1Side2.setTextureSize(128, 64);
+        Can1Side2.mirror = true;
+        setRotation(Can1Side2, 0F, 0F, 0F);
+        Can1Side4 = new ModelRenderer(this, 0, 0);
+        Can1Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can1Side4.setRotationPoint(2F, 11F, 3F);
+        Can1Side4.setTextureSize(128, 64);
+        Can1Side4.mirror = true;
+        setRotation(Can1Side4, 0F, 0F, 0F);
+        Can2Side4 = new ModelRenderer(this, 0, 0);
+        Can2Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can2Side4.setRotationPoint(-6F, 11F, 3F);
+        Can2Side4.setTextureSize(128, 64);
+        Can2Side4.mirror = true;
+        setRotation(Can2Side4, 0F, 0F, 0F);
+        Can3Side3 = new ModelRenderer(this, 0, 0);
+        Can3Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can3Side3.setRotationPoint(5F, 11F, -5F);
+        Can3Side3.setTextureSize(128, 64);
+        Can3Side3.mirror = true;
+        setRotation(Can3Side3, 0F, 0F, 0F);
+        Can2Side2 = new ModelRenderer(this, 0, 0);
+        Can2Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can2Side2.setRotationPoint(-6F, 11F, 2F);
+        Can2Side2.setTextureSize(128, 64);
+        Can2Side2.mirror = true;
+        setRotation(Can2Side2, 0F, 0F, 0F);
+        Can2Side3 = new ModelRenderer(this, 0, 0);
+        Can2Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can2Side3.setRotationPoint(-3F, 11F, 3F);
+        Can2Side3.setTextureSize(128, 64);
+        Can2Side3.mirror = true;
+        setRotation(Can2Side3, 0F, 0F, 0F);
+        Can2Side1 = new ModelRenderer(this, 0, 0);
+        Can2Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can2Side1.setRotationPoint(-6F, 11F, 5F);
+        Can2Side1.setTextureSize(128, 64);
+        Can2Side1.mirror = true;
+        setRotation(Can2Side1, 0F, 0F, 0F);
+        Can4Side3 = new ModelRenderer(this, 0, 0);
+        Can4Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can4Side3.setRotationPoint(-3F, 11F, -5F);
+        Can4Side3.setTextureSize(128, 64);
+        Can4Side3.mirror = true;
+        setRotation(Can4Side3, 0F, 0F, 0F);
+        Can4Side1 = new ModelRenderer(this, 0, 0);
+        Can4Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can4Side1.setRotationPoint(-6F, 11F, -3F);
+        Can4Side1.setTextureSize(128, 64);
+        Can4Side1.mirror = true;
+        setRotation(Can4Side1, 0F, 0F, 0F);
+        Can4Sjde4 = new ModelRenderer(this, 0, 0);
+        Can4Sjde4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can4Sjde4.setRotationPoint(-6F, 11F, -5F);
+        Can4Sjde4.setTextureSize(128, 64);
+        Can4Sjde4.mirror = true;
+        setRotation(Can4Sjde4, 0F, 0F, 0F);
+        Can4Side2 = new ModelRenderer(this, 0, 0);
+        Can4Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can4Side2.setRotationPoint(-6F, 11F, -6F);
+        Can4Side2.setTextureSize(128, 64);
+        Can4Side2.mirror = true;
+        setRotation(Can4Side2, 0F, 0F, 0F);
+        Can3Side4 = new ModelRenderer(this, 0, 0);
+        Can3Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can3Side4.setRotationPoint(2F, 11F, -5F);
+        Can3Side4.setTextureSize(128, 64);
+        Can3Side4.mirror = true;
+        setRotation(Can3Side4, 0F, 0F, 0F);
+        Can4B = new ModelRenderer(this, 0, 0);
+        Can4B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4B.setRotationPoint(-6F, 13F, -6F);
+        Can4B.setTextureSize(128, 64);
+        Can4B.mirror = true;
+        setRotation(Can4B, 0F, 0F, 0F);
+        Can3Side2 = new ModelRenderer(this, 0, 0);
+        Can3Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can3Side2.setRotationPoint(2F, 11F, -6F);
+        Can3Side2.setTextureSize(128, 64);
+        Can3Side2.mirror = true;
+        setRotation(Can3Side2, 0F, 0F, 0F);
+        Can3Side1 = new ModelRenderer(this, 0, 0);
+        Can3Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can3Side1.setRotationPoint(2F, 11F, -3F);
+        Can3Side1.setTextureSize(128, 64);
+        Can3Side1.mirror = true;
+        setRotation(Can3Side1, 0F, 0F, 0F);
+        Can2B = new ModelRenderer(this, 0, 0);
+        Can2B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2B.setRotationPoint(-6F, 13F, 2F);
+        Can2B.setTextureSize(128, 64);
+        Can2B.mirror = true;
+        setRotation(Can2B, 0F, 0F, 0F);
+        Can4T = new ModelRenderer(this, 0, 0);
+        Can4T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4T.setRotationPoint(-6F, 10F, -6F);
+        Can4T.setTextureSize(128, 64);
+        Can4T.mirror = true;
+        setRotation(Can4T, 0F, 0F, 0F);
+        Can2T = new ModelRenderer(this, 0, 0);
+        Can2T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2T.setRotationPoint(-6F, 10F, 2F);
+        Can2T.setTextureSize(128, 64);
+        Can2T.mirror = true;
+        setRotation(Can2T, 0F, 0F, 0F);
+        Can3T = new ModelRenderer(this, 0, 0);
+        Can3T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3T.setRotationPoint(2F, 10F, -6F);
+        Can3T.setTextureSize(128, 64);
+        Can3T.mirror = true;
+        setRotation(Can3T, 0F, 0F, 0F);
+        Can3B = new ModelRenderer(this, 0, 0);
+        Can3B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3B.setRotationPoint(2F, 13F, -6F);
+        Can3B.setTextureSize(128, 64);
+        Can3B.mirror = true;
+        setRotation(Can3B, 0F, 0F, 0F);
+        Spire = new ModelRenderer(this, 0, 6);
+        Spire.addBox(0F, 0F, 0F, 2, 8, 2);
+        Spire.setRotationPoint(-1F, 15F, -1F);
+        Spire.setTextureSize(128, 64);
+        Spire.mirror = true;
+        setRotation(Spire, 0F, 0F, 0F);
+        Spin = new ModelRenderer(this, 28, 24);
+        Spin.addBox(-4F, 0F, -4F, 8, 1, 8);
+        Spin.setRotationPoint(0F, 16F, 0F);
+        Spin.setTextureSize(128, 64);
+        Spin.mirror = true;
+        setRotation(Spin, 0F, 0F, 0F);
+        Vial1 = new ModelRenderer(this, 8, 6);
+        Vial1.addBox(-3F, 0.5F, 3F, 2, 3, 2);
+        Vial1.setRotationPoint(0F, 16F, 0F);
+        Vial1.setTextureSize(128, 64);
+        Vial1.mirror = true;
+        setRotation(Vial1, 0F, 0F, 0F);
+        Vial2 = new ModelRenderer(this, 8, 6);
+        Vial2.addBox(1F, 0.5F, 3F, 2, 3, 2);
+        Vial2.setRotationPoint(0F, 16F, 0F);
+        Vial2.setTextureSize(128, 64);
+        Vial2.mirror = true;
+        setRotation(Vial2, 0F, 0F, 0F);
+        Vial3 = new ModelRenderer(this, 8, 6);
+        Vial3.addBox(-3F, 0.5F, -5F, 2, 3, 2);
+        Vial3.setRotationPoint(0F, 16F, 0F);
+        Vial3.setTextureSize(128, 64);
+        Vial3.mirror = true;
+        setRotation(Vial3, 0F, 0F, 0F);
+        Vial4 = new ModelRenderer(this, 8, 6);
+        Vial4.addBox(1F, 0.5F, -5F, 2, 3, 2);
+        Vial4.setRotationPoint(0F, 16F, 0F);
+        Vial4.setTextureSize(128, 64);
+        Vial4.mirror = true;
+        setRotation(Vial4, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        MekanismRenderer.blendOn();
+
+        Base.render(size);
+        IO1.render(size);
+        IO2.render(size);
+        Base3.render(size);
+        Base2.render(size);
+        Can1B.render(size);
+        Can1T.render(size);
+        Can1Side3.render(size);
+        Can1Side1.render(size);
+        Can1Side2.render(size);
+        Can1Side4.render(size);
+        Can2Side4.render(size);
+        Can3Side3.render(size);
+        Can2Side2.render(size);
+        Can2Side3.render(size);
+        Can2Side1.render(size);
+        Can4Side3.render(size);
+        Can4Side1.render(size);
+        Can4Sjde4.render(size);
+        Can4Side2.render(size);
+        Can3Side4.render(size);
+        Can4B.render(size);
+        Can3Side2.render(size);
+        Can3Side1.render(size);
+        Can2B.render(size);
+        Can4T.render(size);
+        Can2T.render(size);
+        Can3T.render(size);
+        Can3B.render(size);
+        Spire.render(size);
+        Spin.render(size);
+        Vial1.render(size);
+        Vial2.render(size);
+        Vial3.render(size);
+        Vial4.render(size);
+
+        MekanismRenderer.blendOff();
+    }
+
+    public void renderWithRotation(float size, float rotate) {
+        rotate *= Math.PI;
+
+        Spin.rotateAngleY = rotate;
+        Vial1.rotateAngleY = rotate;
+        Vial2.rotateAngleY = rotate;
+        Vial3.rotateAngleY = rotate;
+        Vial4.rotateAngleY = rotate;
+
+        render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChemicalCrystallizer.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChemicalDissolutionChamber.java

@@ -0,0 +1,313 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelChemicalDissolutionChamber extends ModelMekanismBase {
+    ModelRenderer Centre;
+    ModelRenderer Base;
+    ModelRenderer Base2;
+    ModelRenderer Can1B;
+    ModelRenderer Can1T;
+    ModelRenderer Can1Side3;
+    ModelRenderer Can1Side1;
+    ModelRenderer Can1Side2;
+    ModelRenderer Can1Side4;
+    ModelRenderer Can2Side4;
+    ModelRenderer Can3Side3;
+    ModelRenderer Can2Side2;
+    ModelRenderer Can2Side3;
+    ModelRenderer Can2Side1;
+    ModelRenderer Can4Side3;
+    ModelRenderer Can4Side1;
+    ModelRenderer Can4Sjde4;
+    ModelRenderer Can4Side2;
+    ModelRenderer Can3Side4;
+    ModelRenderer Can4B;
+    ModelRenderer Can3Side2;
+    ModelRenderer Can3Side1;
+    ModelRenderer Can2B;
+    ModelRenderer Can4T;
+    ModelRenderer Can2T;
+    ModelRenderer Can3T;
+    ModelRenderer Can3B;
+    ModelRenderer IO1;
+    ModelRenderer IO2Port;
+    ModelRenderer IO2;
+    ModelRenderer IO2Port2;
+    ModelRenderer Coil1;
+    ModelRenderer Coil2;
+    ModelRenderer Coil3;
+    ModelRenderer Coil4;
+
+    public LegacyModelChemicalDissolutionChamber() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        Centre = new ModelRenderer(this, 0, 17);
+        Centre.addBox(0F, 0F, 0F, 2, 13, 2);
+        Centre.setRotationPoint(-1F, 9F, -1F);
+        Centre.setTextureSize(128, 64);
+        Centre.mirror = true;
+        setRotation(Centre, 0F, 0F, 0F);
+        Base = new ModelRenderer(this, 16, 0);
+        Base.addBox(0F, 0F, 0F, 14, 2, 14);
+        Base.setRotationPoint(-7F, 22F, -7F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Base2 = new ModelRenderer(this, 16, 0);
+        Base2.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base2.setRotationPoint(-7F, 16F, -7F);
+        Base2.setTextureSize(128, 64);
+        Base2.mirror = true;
+        setRotation(Base2, 0F, 0F, 0F);
+        Can1B = new ModelRenderer(this, 0, 0);
+        Can1B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1B.setRotationPoint(2F, 21F, 2F);
+        Can1B.setTextureSize(128, 64);
+        Can1B.mirror = true;
+        setRotation(Can1B, 0F, 0F, 0F);
+        Can1T = new ModelRenderer(this, 0, 0);
+        Can1T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1T.setRotationPoint(2F, 17F, 2F);
+        Can1T.setTextureSize(128, 64);
+        Can1T.mirror = true;
+        setRotation(Can1T, 0F, 0F, 0F);
+        Can1Side3 = new ModelRenderer(this, 0, 0);
+        Can1Side3.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can1Side3.setRotationPoint(5F, 18F, 3F);
+        Can1Side3.setTextureSize(128, 64);
+        Can1Side3.mirror = true;
+        setRotation(Can1Side3, 0F, 0F, 0F);
+        Can1Side1 = new ModelRenderer(this, 0, 0);
+        Can1Side1.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can1Side1.setRotationPoint(2F, 18F, 5F);
+        Can1Side1.setTextureSize(128, 64);
+        Can1Side1.mirror = true;
+        setRotation(Can1Side1, 0F, 0F, 0F);
+        Can1Side2 = new ModelRenderer(this, 0, 0);
+        Can1Side2.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can1Side2.setRotationPoint(2F, 18F, 2F);
+        Can1Side2.setTextureSize(128, 64);
+        Can1Side2.mirror = true;
+        setRotation(Can1Side2, 0F, 0F, 0F);
+        Can1Side4 = new ModelRenderer(this, 0, 0);
+        Can1Side4.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can1Side4.setRotationPoint(2F, 18F, 3F);
+        Can1Side4.setTextureSize(128, 64);
+        Can1Side4.mirror = true;
+        setRotation(Can1Side4, 0F, 0F, 0F);
+        Can2Side4 = new ModelRenderer(this, 0, 0);
+        Can2Side4.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can2Side4.setRotationPoint(-6F, 18F, 3F);
+        Can2Side4.setTextureSize(128, 64);
+        Can2Side4.mirror = true;
+        setRotation(Can2Side4, 0F, 0F, 0F);
+        Can3Side3 = new ModelRenderer(this, 0, 0);
+        Can3Side3.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can3Side3.setRotationPoint(5F, 18F, -5F);
+        Can3Side3.setTextureSize(128, 64);
+        Can3Side3.mirror = true;
+        setRotation(Can3Side3, 0F, 0F, 0F);
+        Can2Side2 = new ModelRenderer(this, 0, 0);
+        Can2Side2.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can2Side2.setRotationPoint(-6F, 18F, 2F);
+        Can2Side2.setTextureSize(128, 64);
+        Can2Side2.mirror = true;
+        setRotation(Can2Side2, 0F, 0F, 0F);
+        Can2Side3 = new ModelRenderer(this, 0, 0);
+        Can2Side3.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can2Side3.setRotationPoint(-3F, 18F, 3F);
+        Can2Side3.setTextureSize(128, 64);
+        Can2Side3.mirror = true;
+        setRotation(Can2Side3, 0F, 0F, 0F);
+        Can2Side1 = new ModelRenderer(this, 0, 0);
+        Can2Side1.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can2Side1.setRotationPoint(-6F, 18F, 5F);
+        Can2Side1.setTextureSize(128, 64);
+        Can2Side1.mirror = true;
+        setRotation(Can2Side1, 0F, 0F, 0F);
+        Can4Side3 = new ModelRenderer(this, 0, 0);
+        Can4Side3.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can4Side3.setRotationPoint(-3F, 18F, -5F);
+        Can4Side3.setTextureSize(128, 64);
+        Can4Side3.mirror = true;
+        setRotation(Can4Side3, 0F, 0F, 0F);
+        Can4Side1 = new ModelRenderer(this, 0, 0);
+        Can4Side1.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can4Side1.setRotationPoint(-6F, 18F, -3F);
+        Can4Side1.setTextureSize(128, 64);
+        Can4Side1.mirror = true;
+        setRotation(Can4Side1, 0F, 0F, 0F);
+        Can4Sjde4 = new ModelRenderer(this, 0, 0);
+        Can4Sjde4.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can4Sjde4.setRotationPoint(-6F, 18F, -5F);
+        Can4Sjde4.setTextureSize(128, 64);
+        Can4Sjde4.mirror = true;
+        setRotation(Can4Sjde4, 0F, 0F, 0F);
+        Can4Side2 = new ModelRenderer(this, 0, 0);
+        Can4Side2.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can4Side2.setRotationPoint(-6F, 18F, -6F);
+        Can4Side2.setTextureSize(128, 64);
+        Can4Side2.mirror = true;
+        setRotation(Can4Side2, 0F, 0F, 0F);
+        Can3Side4 = new ModelRenderer(this, 0, 0);
+        Can3Side4.addBox(0F, 0F, 0F, 1, 3, 2);
+        Can3Side4.setRotationPoint(2F, 18F, -5F);
+        Can3Side4.setTextureSize(128, 64);
+        Can3Side4.mirror = true;
+        setRotation(Can3Side4, 0F, 0F, 0F);
+        Can4B = new ModelRenderer(this, 0, 0);
+        Can4B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4B.setRotationPoint(-6F, 21F, -6F);
+        Can4B.setTextureSize(128, 64);
+        Can4B.mirror = true;
+        setRotation(Can4B, 0F, 0F, 0F);
+        Can3Side2 = new ModelRenderer(this, 0, 0);
+        Can3Side2.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can3Side2.setRotationPoint(2F, 18F, -6F);
+        Can3Side2.setTextureSize(128, 64);
+        Can3Side2.mirror = true;
+        setRotation(Can3Side2, 0F, 0F, 0F);
+        Can3Side1 = new ModelRenderer(this, 0, 0);
+        Can3Side1.addBox(0F, 0F, 0F, 4, 3, 1);
+        Can3Side1.setRotationPoint(2F, 18F, -3F);
+        Can3Side1.setTextureSize(128, 64);
+        Can3Side1.mirror = true;
+        setRotation(Can3Side1, 0F, 0F, 0F);
+        Can2B = new ModelRenderer(this, 0, 0);
+        Can2B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2B.setRotationPoint(-6F, 21F, 2F);
+        Can2B.setTextureSize(128, 64);
+        Can2B.mirror = true;
+        setRotation(Can2B, 0F, 0F, 0F);
+        Can4T = new ModelRenderer(this, 0, 0);
+        Can4T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4T.setRotationPoint(-6F, 17F, -6F);
+        Can4T.setTextureSize(128, 64);
+        Can4T.mirror = true;
+        setRotation(Can4T, 0F, 0F, 0F);
+        Can2T = new ModelRenderer(this, 0, 0);
+        Can2T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2T.setRotationPoint(-6F, 17F, 2F);
+        Can2T.setTextureSize(128, 64);
+        Can2T.mirror = true;
+        setRotation(Can2T, 0F, 0F, 0F);
+        Can3T = new ModelRenderer(this, 0, 0);
+        Can3T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3T.setRotationPoint(2F, 17F, -6F);
+        Can3T.setTextureSize(128, 64);
+        Can3T.mirror = true;
+        setRotation(Can3T, 0F, 0F, 0F);
+        Can3B = new ModelRenderer(this, 0, 0);
+        Can3B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3B.setRotationPoint(2F, 21F, -6F);
+        Can3B.setTextureSize(128, 64);
+        Can3B.mirror = true;
+        setRotation(Can3B, 0F, 0F, 0F);
+        IO1 = new ModelRenderer(this, 9, 17);
+        IO1.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO1.setRotationPoint(-8F, 12F, -4F);
+        IO1.setTextureSize(128, 64);
+        IO1.mirror = true;
+        setRotation(IO1, 0F, 0F, 0F);
+        IO2Port = new ModelRenderer(this, 28, 17);
+        IO2Port.addBox(0F, 0F, 0F, 2, 2, 4);
+        IO2Port.setRotationPoint(-7F, 14F, -2F);
+        IO2Port.setTextureSize(128, 64);
+        IO2Port.mirror = true;
+        setRotation(IO2Port, 0F, 0F, 0F);
+        IO2 = new ModelRenderer(this, 9, 17);
+        IO2.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO2.setRotationPoint(7F, 12F, -4F);
+        IO2.setTextureSize(128, 64);
+        IO2.mirror = true;
+        setRotation(IO2, 0F, 0F, 0F);
+        IO2Port2 = new ModelRenderer(this, 28, 17);
+        IO2Port2.addBox(0F, 0F, 0F, 2, 2, 4);
+        IO2Port2.setRotationPoint(5F, 14F, -2F);
+        IO2Port2.setTextureSize(128, 64);
+        IO2Port2.mirror = true;
+        setRotation(IO2Port2, 0F, 0F, 0F);
+        Coil1 = new ModelRenderer(this, 0, 34);
+        Coil1.addBox(0F, 0F, 0F, 8, 1, 8);
+        Coil1.setRotationPoint(-4F, 14F, -4F);
+        Coil1.setTextureSize(128, 64);
+        Coil1.mirror = true;
+        setRotation(Coil1, 0F, 0F, 0F);
+        Coil2 = new ModelRenderer(this, 0, 34);
+        Coil2.addBox(0F, 0F, 0F, 8, 1, 8);
+        Coil2.setRotationPoint(-4F, 12F, -4F);
+        Coil2.setTextureSize(128, 64);
+        Coil2.mirror = true;
+        setRotation(Coil2, 0F, 0F, 0F);
+        Coil3 = new ModelRenderer(this, 0, 34);
+        Coil3.addBox(0F, 0F, 0F, 8, 1, 8);
+        Coil3.setRotationPoint(-4F, 10F, -4F);
+        Coil3.setTextureSize(128, 64);
+        Coil3.mirror = true;
+        setRotation(Coil3, 0F, 0F, 0F);
+        Coil4 = new ModelRenderer(this, 0, 34);
+        Coil4.addBox(0F, 0F, 0F, 8, 1, 8);
+        Coil4.setRotationPoint(-4F, 8F, -4F);
+        Coil4.setTextureSize(128, 64);
+        Coil4.mirror = true;
+        setRotation(Coil4, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        MekanismRenderer.blendOn();
+
+        Centre.render(size);
+        Base.render(size);
+        Base2.render(size);
+        Can1B.render(size);
+        Can1T.render(size);
+        Can1Side3.render(size);
+        Can1Side1.render(size);
+        Can1Side2.render(size);
+        Can1Side4.render(size);
+        Can2Side4.render(size);
+        Can3Side3.render(size);
+        Can2Side2.render(size);
+        Can2Side3.render(size);
+        Can2Side1.render(size);
+        Can4Side3.render(size);
+        Can4Side1.render(size);
+        Can4Sjde4.render(size);
+        Can4Side2.render(size);
+        Can3Side4.render(size);
+        Can4B.render(size);
+        Can3Side2.render(size);
+        Can3Side1.render(size);
+        Can2B.render(size);
+        Can4T.render(size);
+        Can2T.render(size);
+        Can3T.render(size);
+        Can3B.render(size);
+        IO1.render(size);
+        IO2Port.render(size);
+        IO2.render(size);
+        IO2Port2.render(size);
+        Coil1.render(size);
+        Coil2.render(size);
+        Coil3.render(size);
+        Coil4.render(size);
+
+        MekanismRenderer.blendOff();
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChemicalDissolutionChamber.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChemicalInfuser.java

@@ -0,0 +1,342 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+import org.lwjgl.opengl.GL11;
+
+public class LegacyModelChemicalInfuser extends ModelMekanismBase implements IModelGlass {
+    ModelRenderer Base;
+    ModelRenderer GasExit;
+    ModelRenderer GasLeft;
+    ModelRenderer GasRight;
+    ModelRenderer MachineCore;
+    ModelRenderer TopPanel;
+    ModelRenderer SidePanel;
+    ModelRenderer LPanelNW;
+    ModelRenderer RPanelNW;
+    ModelRenderer RPanelNE;
+    ModelRenderer LPanelSW;
+    ModelRenderer RPanelSW;
+    ModelRenderer RPanelSE;
+    ModelRenderer LPanelNE;
+    ModelRenderer LPanelSE;
+    ModelRenderer LTopS;
+    ModelRenderer RTopN;
+    ModelRenderer LTopN;
+    ModelRenderer RTopS;
+    ModelRenderer RTopW;
+    ModelRenderer RTopE;
+    ModelRenderer LTopE;
+    ModelRenderer LTopW;
+    ModelRenderer FrontPanel;
+    ModelRenderer FrontConnection;
+    ModelRenderer RightConnection;
+    ModelRenderer LeftConnection;
+    ModelRenderer LGlassT;
+    ModelRenderer RGlassT;
+    ModelRenderer LGlassS;
+    ModelRenderer RGlassS;
+    ModelRenderer RGlassN;
+    ModelRenderer LGlassN;
+    ModelRenderer LGlassL;
+    ModelRenderer RGlassR;
+    ModelRenderer RGlassL;
+    ModelRenderer LGlassR;
+
+    public LegacyModelChemicalInfuser() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 16, 1, 16);
+        Base.setRotationPoint(-8F, 23F, -8F);
+        Base.setTextureSize(128, 128);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        GasExit = new ModelRenderer(this, 0, 17);
+        GasExit.addBox(0F, 0F, 0F, 6, 6, 1);
+        GasExit.setRotationPoint(-3F, 13F, -8F);
+        GasExit.setTextureSize(128, 128);
+        GasExit.mirror = true;
+        setRotation(GasExit, 0F, 0F, 0F);
+        GasLeft = new ModelRenderer(this, 64, 0);
+        GasLeft.addBox(0F, 0F, 0F, 1, 6, 6);
+        GasLeft.setRotationPoint(-8F, 13F, -3F);
+        GasLeft.setTextureSize(128, 128);
+        GasLeft.mirror = true;
+        setRotation(GasLeft, 0F, 0F, 0F);
+        GasRight = new ModelRenderer(this, 64, 0);
+        GasRight.addBox(0F, 0F, 0F, 1, 6, 6);
+        GasRight.setRotationPoint(7F, 13F, -3F);
+        GasRight.setTextureSize(128, 128);
+        GasRight.mirror = true;
+        setRotation(GasRight, 0F, 0F, 0F);
+        MachineCore = new ModelRenderer(this, 0, 24);
+        MachineCore.addBox(0F, 0F, 0F, 10, 11, 5);
+        MachineCore.setRotationPoint(-5F, 12F, -4F);
+        MachineCore.setTextureSize(128, 128);
+        MachineCore.mirror = true;
+        setRotation(MachineCore, 0F, 0F, 0F);
+        TopPanel = new ModelRenderer(this, 0, 40);
+        TopPanel.addBox(0F, 0F, 0F, 2, 1, 8);
+        TopPanel.setRotationPoint(-1F, 11F, -3F);
+        TopPanel.setTextureSize(128, 128);
+        TopPanel.mirror = true;
+        setRotation(TopPanel, 0F, 0F, 0F);
+        SidePanel = new ModelRenderer(this, 30, 17);
+        SidePanel.addBox(0F, 0F, 0F, 2, 11, 1);
+        SidePanel.setRotationPoint(-1F, 12F, 4F);
+        SidePanel.setTextureSize(128, 128);
+        SidePanel.mirror = true;
+        setRotation(SidePanel, 0F, 0F, 0F);
+        LPanelNW = new ModelRenderer(this, 78, 0);
+        LPanelNW.addBox(0F, 0F, 0F, 1, 15, 1);
+        LPanelNW.setRotationPoint(-6F, 8F, 1F);
+        LPanelNW.setTextureSize(128, 128);
+        LPanelNW.mirror = true;
+        setRotation(LPanelNW, 0F, 0F, 0F);
+        RPanelNW = new ModelRenderer(this, 78, 0);
+        RPanelNW.addBox(0F, 0F, 0F, 1, 15, 1);
+        RPanelNW.setRotationPoint(1F, 8F, 1F);
+        RPanelNW.setTextureSize(128, 128);
+        RPanelNW.mirror = true;
+        setRotation(RPanelNW, 0F, 0F, 0F);
+        RPanelNE = new ModelRenderer(this, 78, 0);
+        RPanelNE.addBox(7F, 0F, 0F, 1, 15, 1);
+        RPanelNE.setRotationPoint(-2F, 8F, 1F);
+        RPanelNE.setTextureSize(128, 128);
+        RPanelNE.mirror = true;
+        setRotation(RPanelNE, 0F, 0F, 0F);
+        LPanelSW = new ModelRenderer(this, 78, 0);
+        LPanelSW.addBox(0F, 0F, 0F, 1, 15, 1);
+        LPanelSW.setRotationPoint(-6F, 8F, 5F);
+        LPanelSW.setTextureSize(128, 128);
+        LPanelSW.mirror = true;
+        setRotation(LPanelSW, 0F, 0F, 0F);
+        RPanelSW = new ModelRenderer(this, 78, 0);
+        RPanelSW.addBox(0F, 0F, 0F, 1, 15, 1);
+        RPanelSW.setRotationPoint(1F, 8F, 5F);
+        RPanelSW.setTextureSize(128, 128);
+        RPanelSW.mirror = true;
+        setRotation(RPanelSW, 0F, 0F, 0F);
+        RPanelSE = new ModelRenderer(this, 78, 0);
+        RPanelSE.addBox(0F, 0F, 0F, 1, 15, 1);
+        RPanelSE.setRotationPoint(5F, 8F, 5F);
+        RPanelSE.setTextureSize(128, 128);
+        RPanelSE.mirror = true;
+        setRotation(RPanelSE, 0F, 0F, 0F);
+        LPanelNE = new ModelRenderer(this, 78, 0);
+        LPanelNE.addBox(0F, 0F, 0F, 1, 15, 1);
+        LPanelNE.setRotationPoint(-2F, 8F, 1F);
+        LPanelNE.setTextureSize(128, 128);
+        LPanelNE.mirror = true;
+        setRotation(LPanelNE, 0F, 0F, 0F);
+        LPanelSE = new ModelRenderer(this, 78, 0);
+        LPanelSE.addBox(0F, 0F, 0F, 1, 15, 1);
+        LPanelSE.setRotationPoint(-2F, 8F, 5F);
+        LPanelSE.setTextureSize(128, 128);
+        LPanelSE.mirror = true;
+        setRotation(LPanelSE, 0F, 0F, 0F);
+        LTopS = new ModelRenderer(this, 82, 0);
+        LTopS.addBox(0F, 0F, 4F, 3, 1, 1);
+        LTopS.setRotationPoint(-5F, 8F, 1F);
+        LTopS.setTextureSize(128, 128);
+        LTopS.mirror = true;
+        setRotation(LTopS, 0F, 0F, 0F);
+        RTopN = new ModelRenderer(this, 82, 0);
+        RTopN.addBox(0F, 0F, 0F, 3, 1, 1);
+        RTopN.setRotationPoint(2F, 8F, 1F);
+        RTopN.setTextureSize(128, 128);
+        RTopN.mirror = true;
+        setRotation(RTopN, 0F, 0F, 0F);
+        LTopN = new ModelRenderer(this, 82, 0);
+        LTopN.addBox(0F, 0F, 0F, 3, 1, 1);
+        LTopN.setRotationPoint(-5F, 8F, 1F);
+        LTopN.setTextureSize(128, 128);
+        LTopN.mirror = true;
+        setRotation(LTopN, 0F, 0F, 0F);
+        RTopS = new ModelRenderer(this, 82, 0);
+        RTopS.addBox(0F, 0F, 4F, 3, 1, 1);
+        RTopS.setRotationPoint(2F, 8F, 1F);
+        RTopS.setTextureSize(128, 128);
+        RTopS.mirror = true;
+        setRotation(RTopS, 0F, 0F, 0F);
+        RTopW = new ModelRenderer(this, 90, 0);
+        RTopW.addBox(0F, 0F, 0F, 1, 1, 3);
+        RTopW.setRotationPoint(1F, 8F, 2F);
+        RTopW.setTextureSize(128, 128);
+        RTopW.mirror = true;
+        setRotation(RTopW, 0F, 0F, 0F);
+        RTopE = new ModelRenderer(this, 90, 0);
+        RTopE.addBox(0F, 1F, 0F, 1, 1, 3);
+        RTopE.setRotationPoint(5F, 7F, 2F);
+        RTopE.setTextureSize(128, 128);
+        RTopE.mirror = true;
+        setRotation(RTopE, 0F, 0F, 0F);
+        LTopE = new ModelRenderer(this, 90, 0);
+        LTopE.addBox(0F, 0F, 0F, 1, 1, 3);
+        LTopE.setRotationPoint(-2F, 8F, 2F);
+        LTopE.setTextureSize(128, 128);
+        LTopE.mirror = true;
+        setRotation(LTopE, 0F, 0F, 0F);
+        LTopW = new ModelRenderer(this, 90, 0);
+        LTopW.addBox(0F, 0F, 0F, 1, 1, 3);
+        LTopW.setRotationPoint(-6F, 8F, 2F);
+        LTopW.setTextureSize(128, 128);
+        LTopW.mirror = true;
+        setRotation(LTopW, 0F, 0F, 0F);
+        FrontPanel = new ModelRenderer(this, 0, 49);
+        FrontPanel.addBox(0F, 0F, 0F, 8, 9, 1);
+        FrontPanel.setRotationPoint(-4F, 13F, -5F);
+        FrontPanel.setTextureSize(128, 128);
+        FrontPanel.mirror = true;
+        setRotation(FrontPanel, 0F, 0F, 0F);
+        FrontConnection = new ModelRenderer(this, 0, 59);
+        FrontConnection.addBox(0F, 0F, 0F, 4, 4, 2);
+        FrontConnection.setRotationPoint(-2F, 14F, -7F);
+        FrontConnection.setTextureSize(128, 128);
+        FrontConnection.mirror = true;
+        setRotation(FrontConnection, 0F, 0F, 0F);
+        RightConnection = new ModelRenderer(this, 98, 0);
+        RightConnection.addBox(0F, 0F, 0F, 2, 4, 4);
+        RightConnection.setRotationPoint(5F, 14F, -2F);
+        RightConnection.setTextureSize(128, 128);
+        RightConnection.mirror = true;
+        setRotation(RightConnection, 0F, 0F, 0F);
+        LeftConnection = new ModelRenderer(this, 98, 0);
+        LeftConnection.addBox(0F, 0F, 0F, 2, 4, 4);
+        LeftConnection.setRotationPoint(-7F, 14F, -2F);
+        LeftConnection.setTextureSize(128, 128);
+        LeftConnection.mirror = true;
+        setRotation(LeftConnection, 0F, 0F, 0F);
+        LGlassT = new ModelRenderer(this, 36, 17);
+        LGlassT.addBox(0F, 0F, 0F, 3, 1, 3);
+        LGlassT.setRotationPoint(-5F, 8F, 2F);
+        LGlassT.setTextureSize(128, 128);
+        LGlassT.mirror = true;
+        setRotation(LGlassT, 0F, 0F, 0F);
+        RGlassT = new ModelRenderer(this, 36, 17);
+        RGlassT.addBox(0F, 0F, 0F, 3, 1, 3);
+        RGlassT.setRotationPoint(2F, 8F, 2F);
+        RGlassT.setTextureSize(128, 128);
+        RGlassT.mirror = true;
+        setRotation(RGlassT, 0F, 0F, 0F);
+        LGlassS = new ModelRenderer(this, 48, 17);
+        LGlassS.addBox(0F, 0F, 0F, 3, 14, 1);
+        LGlassS.setRotationPoint(-5F, 9F, 5F);
+        LGlassS.setTextureSize(128, 128);
+        LGlassS.mirror = true;
+        setRotation(LGlassS, 0F, 0F, 0F);
+        RGlassS = new ModelRenderer(this, 48, 17);
+        RGlassS.addBox(0F, 0F, 0F, 3, 14, 1);
+        RGlassS.setRotationPoint(2F, 9F, 5F);
+        RGlassS.setTextureSize(128, 128);
+        RGlassS.mirror = true;
+        setRotation(RGlassS, 0F, 0F, 0F);
+        RGlassN = new ModelRenderer(this, 48, 17);
+        RGlassN.addBox(0F, 0F, 0F, 3, 14, 1);
+        RGlassN.setRotationPoint(2F, 9F, 1F);
+        RGlassN.setTextureSize(128, 128);
+        RGlassN.mirror = true;
+        setRotation(RGlassN, 0F, 0F, 0F);
+        LGlassN = new ModelRenderer(this, 48, 17);
+        LGlassN.addBox(0F, 0F, 0F, 3, 14, 1);
+        LGlassN.setRotationPoint(-5F, 9F, 1F);
+        LGlassN.setTextureSize(128, 128);
+        LGlassN.mirror = true;
+        setRotation(LGlassN, 0F, 0F, 0F);
+        LGlassL = new ModelRenderer(this, 0, 65);
+        LGlassL.addBox(0F, 0F, 0F, 1, 14, 3);
+        LGlassL.setRotationPoint(-6F, 9F, 2F);
+        LGlassL.setTextureSize(128, 128);
+        LGlassL.mirror = true;
+        setRotation(LGlassL, 0F, 0F, 0F);
+        RGlassR = new ModelRenderer(this, 0, 65);
+        RGlassR.addBox(0F, 0F, 0F, 1, 14, 3);
+        RGlassR.setRotationPoint(5F, 9F, 2F);
+        RGlassR.setTextureSize(128, 128);
+        RGlassR.mirror = true;
+        setRotation(RGlassR, 0F, 0F, 0F);
+        RGlassL = new ModelRenderer(this, 0, 65);
+        RGlassL.addBox(0F, 0F, 0F, 1, 14, 3);
+        RGlassL.setRotationPoint(1F, 9F, 2F);
+        RGlassL.setTextureSize(128, 128);
+        RGlassL.mirror = true;
+        setRotation(RGlassL, 0F, 0F, 0F);
+        LGlassR = new ModelRenderer(this, 0, 65);
+        LGlassR.addBox(0F, 0F, 0F, 1, 14, 3);
+        LGlassR.setRotationPoint(-2F, 9F, 2F);
+        LGlassR.setTextureSize(128, 128);
+        LGlassR.mirror = true;
+        setRotation(LGlassR, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        GasExit.render(size);
+        GasLeft.render(size);
+        GasRight.render(size);
+        MachineCore.render(size);
+        TopPanel.render(size);
+        SidePanel.render(size);
+        LPanelNW.render(size);
+        RPanelNW.render(size);
+        RPanelNE.render(size);
+        LPanelSW.render(size);
+        RPanelSW.render(size);
+        RPanelSE.render(size);
+        LPanelNE.render(size);
+        LPanelSE.render(size);
+        LTopS.render(size);
+        RTopN.render(size);
+        LTopN.render(size);
+        RTopS.render(size);
+        RTopW.render(size);
+        RTopE.render(size);
+        LTopE.render(size);
+        LTopW.render(size);
+        FrontPanel.render(size);
+        FrontConnection.render(size);
+
+        GL11.glPushMatrix();
+        GL11.glScalef(0.999F, 0.999F, 0.999F);
+        RightConnection.render(size);
+        LeftConnection.render(size);
+        GL11.glPopMatrix();
+    }
+
+    @Override
+    public void renderGlass(float size) {
+        GL11.glPushMatrix();
+        MekanismRenderer.blendOn();
+        GL11.glColor4f(1, 1, 1, 0.2F);
+
+        LGlassT.render(size);
+        RGlassT.render(size);
+        LGlassS.render(size);
+        RGlassS.render(size);
+        RGlassN.render(size);
+        LGlassN.render(size);
+        LGlassL.render(size);
+        RGlassR.render(size);
+        RGlassL.render(size);
+        LGlassR.render(size);
+
+        MekanismRenderer.blendOff();
+        GL11.glColor4f(1, 1, 1, 1);
+        GL11.glPopMatrix();
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChemicalInfuser.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChemicalOxidizer.java

@@ -0,0 +1,202 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+import org.lwjgl.opengl.GL11;
+
+public class LegacyModelChemicalOxidizer extends ModelMekanismBase implements IModelGlass {
+    ModelRenderer Base;
+    ModelRenderer TSSW;
+    ModelRenderer TSNW;
+    ModelRenderer TSSE;
+    ModelRenderer TSNE;
+    ModelRenderer TTN;
+    ModelRenderer TTS;
+    ModelRenderer TTE;
+    ModelRenderer TTW;
+    ModelRenderer Connection;
+    ModelRenderer ItemEntry;
+    ModelRenderer GasExit;
+    ModelRenderer GasConnection;
+    ModelRenderer Machine;
+    ModelRenderer Post;
+    ModelRenderer GlassN;
+    ModelRenderer GlassS;
+    ModelRenderer GlassW;
+    ModelRenderer GlassE;
+    ModelRenderer GlassU;
+
+    public LegacyModelChemicalOxidizer() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 16, 1, 16);
+        Base.setRotationPoint(-8F, 23F, -8F);
+        Base.setTextureSize(128, 128);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        TSSW = new ModelRenderer(this, 0, 17);
+        TSSW.addBox(0F, 0F, 0F, 1, 15, 1);
+        TSSW.setRotationPoint(-1F, 8F, 3F);
+        TSSW.setTextureSize(128, 128);
+        TSSW.mirror = true;
+        setRotation(TSSW, 0F, 0F, 0F);
+        TSNW = new ModelRenderer(this, 0, 17);
+        TSNW.addBox(0F, 0F, 0F, 1, 15, 1);
+        TSNW.setRotationPoint(-1F, 8F, -4F);
+        TSNW.setTextureSize(128, 128);
+        TSNW.mirror = true;
+        setRotation(TSNW, 0F, 0F, 0F);
+        TSSE = new ModelRenderer(this, 0, 17);
+        TSSE.addBox(0F, 0F, 0F, 1, 15, 1);
+        TSSE.setRotationPoint(6F, 8F, 3F);
+        TSSE.setTextureSize(128, 128);
+        TSSE.mirror = true;
+        setRotation(TSSE, 0F, 0F, 0F);
+        TSNE = new ModelRenderer(this, 0, 17);
+        TSNE.addBox(0F, 0F, 0F, 1, 15, 1);
+        TSNE.setRotationPoint(6F, 8F, -4F);
+        TSNE.setTextureSize(128, 128);
+        TSNE.mirror = true;
+        setRotation(TSNE, 0F, 0F, 0F);
+        TTN = new ModelRenderer(this, 4, 17);
+        TTN.addBox(0F, 0F, 0F, 6, 1, 1);
+        TTN.setRotationPoint(0F, 8F, -4F);
+        TTN.setTextureSize(128, 128);
+        TTN.mirror = true;
+        setRotation(TTN, 0F, 0F, 0F);
+        TTS = new ModelRenderer(this, 4, 17);
+        TTS.addBox(0F, 0F, 0F, 6, 1, 1);
+        TTS.setRotationPoint(0F, 8F, 3F);
+        TTS.setTextureSize(128, 128);
+        TTS.mirror = true;
+        setRotation(TTS, 0F, 0F, 0F);
+        TTE = new ModelRenderer(this, 18, 17);
+        TTE.addBox(0F, 0F, 0F, 1, 1, 6);
+        TTE.setRotationPoint(6F, 8F, -3F);
+        TTE.setTextureSize(128, 128);
+        TTE.mirror = true;
+        setRotation(TTE, 0F, 0F, 0F);
+        TTW = new ModelRenderer(this, 18, 17);
+        TTW.addBox(0F, 0F, 0F, 1, 1, 6);
+        TTW.setRotationPoint(-1F, 8F, -3F);
+        TTW.setTextureSize(128, 128);
+        TTW.mirror = true;
+        setRotation(TTW, 0F, 0F, 0F);
+        Connection = new ModelRenderer(this, 32, 17);
+        Connection.addBox(0F, 0F, 0F, 7, 4, 4);
+        Connection.setRotationPoint(-7F, 14F, -2F);
+        Connection.setTextureSize(128, 128);
+        Connection.mirror = true;
+        setRotation(Connection, 0F, 0F, 0F);
+        ItemEntry = new ModelRenderer(this, 64, 0);
+        ItemEntry.addBox(0F, 0F, 0F, 1, 8, 8);
+        ItemEntry.setRotationPoint(-8F, 12F, -4F);
+        ItemEntry.setTextureSize(128, 128);
+        ItemEntry.mirror = true;
+        setRotation(ItemEntry, 0F, 0F, 0F);
+        GasExit = new ModelRenderer(this, 0, 33);
+        GasExit.addBox(0F, 1F, 0F, 1, 6, 6);
+        GasExit.setRotationPoint(7F, 12F, -3F);
+        GasExit.setTextureSize(128, 128);
+        GasExit.mirror = true;
+        setRotation(GasExit, 0F, 0F, 0F);
+        GasConnection = new ModelRenderer(this, 82, 0);
+        GasConnection.addBox(0F, 1F, 0F, 1, 4, 4);
+        GasConnection.setRotationPoint(6F, 13F, -2F);
+        GasConnection.setTextureSize(128, 128);
+        GasConnection.mirror = true;
+        setRotation(GasConnection, 0F, 0F, 0F);
+        Machine = new ModelRenderer(this, 0, 45);
+        Machine.addBox(0F, 0F, 0F, 4, 6, 6);
+        Machine.setRotationPoint(-6F, 13F, -3F);
+        Machine.setTextureSize(128, 128);
+        Machine.mirror = true;
+        setRotation(Machine, 0F, 0F, 0F);
+        Post = new ModelRenderer(this, 0, 57);
+        Post.addBox(0F, 0F, 0F, 2, 4, 2);
+        Post.setRotationPoint(-5F, 19F, -1F);
+        Post.setTextureSize(128, 128);
+        Post.mirror = true;
+        setRotation(Post, 0F, 0F, 0F);
+        GlassN = new ModelRenderer(this, 92, 0);
+        GlassN.addBox(0F, 0F, 0F, 6, 14, 1);
+        GlassN.setRotationPoint(0F, 9F, -4F);
+        GlassN.setTextureSize(128, 128);
+        GlassN.mirror = true;
+        setRotation(GlassN, 0F, 0F, 0F);
+        GlassS = new ModelRenderer(this, 92, 0);
+        GlassS.addBox(0F, 0F, 0F, 6, 14, 1);
+        GlassS.setRotationPoint(0F, 9F, 3F);
+        GlassS.setTextureSize(128, 128);
+        GlassS.mirror = true;
+        setRotation(GlassS, 0F, 0F, 0F);
+        GlassW = new ModelRenderer(this, 0, 70);
+        GlassW.addBox(0F, 0F, 0F, 1, 14, 6);
+        GlassW.setRotationPoint(-1F, 9F, -3F);
+        GlassW.setTextureSize(128, 128);
+        GlassW.mirror = true;
+        setRotation(GlassW, 0F, 0F, 0F);
+        GlassE = new ModelRenderer(this, 0, 70);
+        GlassE.addBox(0F, 0F, 0F, 1, 14, 6);
+        GlassE.setRotationPoint(6F, 9F, -3F);
+        GlassE.setTextureSize(128, 128);
+        GlassE.mirror = true;
+        setRotation(GlassE, 0F, 0F, 0F);
+        GlassU = new ModelRenderer(this, 0, 63);
+        GlassU.addBox(0F, 0F, 0F, 6, 1, 6);
+        GlassU.setRotationPoint(0F, 8F, -3F);
+        GlassU.setTextureSize(128, 128);
+        GlassU.mirror = true;
+        setRotation(GlassU, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        TSSW.render(size);
+        TSNW.render(size);
+        TSSE.render(size);
+        TSNE.render(size);
+        TTN.render(size);
+        TTS.render(size);
+        TTE.render(size);
+        TTW.render(size);
+        Connection.render(size);
+        ItemEntry.render(size);
+        GasExit.render(size);
+        GasConnection.render(size);
+        Machine.render(size);
+        Post.render(size);
+    }
+
+    @Override
+    public void renderGlass(float size) {
+        GL11.glPushMatrix();
+        MekanismRenderer.blendOn();
+        GL11.glColor4f(1, 1, 1, 0.2F);
+
+        GlassN.render(size);
+        GlassS.render(size);
+        GlassW.render(size);
+        GlassE.render(size);
+        GlassU.render(size);
+
+        MekanismRenderer.blendOff();
+        GL11.glColor4f(1, 1, 1, 1);
+        GL11.glPopMatrix();
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChemicalOxidizer.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelChemicalWasher.java

@@ -0,0 +1,298 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelChemicalWasher extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer Base2;
+    ModelRenderer IO1;
+    ModelRenderer IO2;
+    ModelRenderer IO3;
+    ModelRenderer Base3;
+    ModelRenderer Base4;
+    ModelRenderer Base5;
+    ModelRenderer Base6;
+    ModelRenderer Can1B;
+    ModelRenderer Can1T;
+    ModelRenderer Can1Side3;
+    ModelRenderer Can1Side1;
+    ModelRenderer Can1Side2;
+    ModelRenderer Can1Side4;
+    ModelRenderer Can2Side4;
+    ModelRenderer Can3Side3;
+    ModelRenderer Can2Side2;
+    ModelRenderer Can2Side3;
+    ModelRenderer Can2Side1;
+    ModelRenderer Can4Side3;
+    ModelRenderer Can4Side1;
+    ModelRenderer Can4Sjde4;
+    ModelRenderer Can4Side2;
+    ModelRenderer Can3Side4;
+    ModelRenderer Can4B;
+    ModelRenderer Can3Side2;
+    ModelRenderer Can3Side1;
+    ModelRenderer Can2B;
+    ModelRenderer Can4T;
+    ModelRenderer Can2T;
+    ModelRenderer Can3T;
+    ModelRenderer Can3B;
+
+    public LegacyModelChemicalWasher() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        Base = new ModelRenderer(this, 16, 0);
+        Base.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base.setRotationPoint(-7F, 23F, -7F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Base2 = new ModelRenderer(this, 72, 0);
+        Base2.addBox(0F, 0F, 0F, 14, 10, 1);
+        Base2.setRotationPoint(-7F, 8F, 6F);
+        Base2.setTextureSize(128, 64);
+        Base2.mirror = true;
+        setRotation(Base2, 0F, 0F, 0F);
+        Base2.mirror = false;
+        IO1 = new ModelRenderer(this, 9, 17);
+        IO1.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO1.setRotationPoint(-8F, 12F, -4F);
+        IO1.setTextureSize(128, 64);
+        IO1.mirror = true;
+        setRotation(IO1, 0F, 0F, 0F);
+        IO2 = new ModelRenderer(this, 9, 17);
+        IO2.addBox(0F, 0F, 0F, 1, 8, 8);
+        IO2.setRotationPoint(7F, 12F, -4F);
+        IO2.setTextureSize(128, 64);
+        IO2.mirror = true;
+        setRotation(IO2, 0F, 0F, 0F);
+        IO3 = new ModelRenderer(this, 0, 42);
+        IO3.addBox(0F, 0F, 0F, 12, 1, 8);
+        IO3.setRotationPoint(-6F, 8F, -4F);
+        IO3.setTextureSize(128, 64);
+        IO3.mirror = true;
+        setRotation(IO3, 0F, 0F, 0F);
+        Base3 = new ModelRenderer(this, 72, 0);
+        Base3.addBox(0F, 0F, 0F, 14, 10, 1);
+        Base3.setRotationPoint(-7F, 8F, -7F);
+        Base3.setTextureSize(128, 64);
+        Base3.mirror = true;
+        setRotation(Base3, 0F, 0F, 0F);
+        Base4 = new ModelRenderer(this, 72, 12);
+        Base4.addBox(0F, 0F, 0F, 1, 10, 12);
+        Base4.setRotationPoint(6F, 8F, -6F);
+        Base4.setTextureSize(128, 64);
+        Base4.mirror = true;
+        setRotation(Base4, 0F, 0F, 0F);
+        Base5 = new ModelRenderer(this, 72, 12);
+        Base5.addBox(0F, 0F, 0F, 1, 10, 12);
+        Base5.setRotationPoint(-7F, 8F, -6F);
+        Base5.setTextureSize(128, 64);
+        Base5.mirror = true;
+        setRotation(Base5, 0F, 0F, 0F);
+        Base6 = new ModelRenderer(this, 16, 0);
+        Base6.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base6.setRotationPoint(-7F, 18F, -7F);
+        Base6.setTextureSize(128, 64);
+        Base6.mirror = true;
+        setRotation(Base6, 0F, 0F, 0F);
+        Can1B = new ModelRenderer(this, 0, 0);
+        Can1B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1B.setRotationPoint(2F, 22F, 2F);
+        Can1B.setTextureSize(128, 64);
+        Can1B.mirror = true;
+        setRotation(Can1B, 0F, 0F, 0F);
+        Can1T = new ModelRenderer(this, 0, 0);
+        Can1T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can1T.setRotationPoint(2F, 19F, 2F);
+        Can1T.setTextureSize(128, 64);
+        Can1T.mirror = true;
+        setRotation(Can1T, 0F, 0F, 0F);
+        Can1Side3 = new ModelRenderer(this, 0, 0);
+        Can1Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can1Side3.setRotationPoint(5F, 20F, 3F);
+        Can1Side3.setTextureSize(128, 64);
+        Can1Side3.mirror = true;
+        setRotation(Can1Side3, 0F, 0F, 0F);
+        Can1Side1 = new ModelRenderer(this, 0, 0);
+        Can1Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can1Side1.setRotationPoint(2F, 20F, 5F);
+        Can1Side1.setTextureSize(128, 64);
+        Can1Side1.mirror = true;
+        setRotation(Can1Side1, 0F, 0F, 0F);
+        Can1Side2 = new ModelRenderer(this, 0, 0);
+        Can1Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can1Side2.setRotationPoint(2F, 20F, 2F);
+        Can1Side2.setTextureSize(128, 64);
+        Can1Side2.mirror = true;
+        setRotation(Can1Side2, 0F, 0F, 0F);
+        Can1Side4 = new ModelRenderer(this, 0, 0);
+        Can1Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can1Side4.setRotationPoint(2F, 20F, 3F);
+        Can1Side4.setTextureSize(128, 64);
+        Can1Side4.mirror = true;
+        setRotation(Can1Side4, 0F, 0F, 0F);
+        Can2Side4 = new ModelRenderer(this, 0, 0);
+        Can2Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can2Side4.setRotationPoint(-6F, 20F, 3F);
+        Can2Side4.setTextureSize(128, 64);
+        Can2Side4.mirror = true;
+        setRotation(Can2Side4, 0F, 0F, 0F);
+        Can3Side3 = new ModelRenderer(this, 0, 0);
+        Can3Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can3Side3.setRotationPoint(5F, 20F, -5F);
+        Can3Side3.setTextureSize(128, 64);
+        Can3Side3.mirror = true;
+        setRotation(Can3Side3, 0F, 0F, 0F);
+        Can2Side2 = new ModelRenderer(this, 0, 0);
+        Can2Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can2Side2.setRotationPoint(-6F, 20F, 2F);
+        Can2Side2.setTextureSize(128, 64);
+        Can2Side2.mirror = true;
+        setRotation(Can2Side2, 0F, 0F, 0F);
+        Can2Side3 = new ModelRenderer(this, 0, 0);
+        Can2Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can2Side3.setRotationPoint(-3F, 20F, 3F);
+        Can2Side3.setTextureSize(128, 64);
+        Can2Side3.mirror = true;
+        setRotation(Can2Side3, 0F, 0F, 0F);
+        Can2Side1 = new ModelRenderer(this, 0, 0);
+        Can2Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can2Side1.setRotationPoint(-6F, 20F, 5F);
+        Can2Side1.setTextureSize(128, 64);
+        Can2Side1.mirror = true;
+        setRotation(Can2Side1, 0F, 0F, 0F);
+        Can4Side3 = new ModelRenderer(this, 0, 0);
+        Can4Side3.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can4Side3.setRotationPoint(-3F, 20F, -5F);
+        Can4Side3.setTextureSize(128, 64);
+        Can4Side3.mirror = true;
+        setRotation(Can4Side3, 0F, 0F, 0F);
+        Can4Side1 = new ModelRenderer(this, 0, 0);
+        Can4Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can4Side1.setRotationPoint(-6F, 20F, -3F);
+        Can4Side1.setTextureSize(128, 64);
+        Can4Side1.mirror = true;
+        setRotation(Can4Side1, 0F, 0F, 0F);
+        Can4Sjde4 = new ModelRenderer(this, 0, 0);
+        Can4Sjde4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can4Sjde4.setRotationPoint(-6F, 20F, -5F);
+        Can4Sjde4.setTextureSize(128, 64);
+        Can4Sjde4.mirror = true;
+        setRotation(Can4Sjde4, 0F, 0F, 0F);
+        Can4Side2 = new ModelRenderer(this, 0, 0);
+        Can4Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can4Side2.setRotationPoint(-6F, 20F, -6F);
+        Can4Side2.setTextureSize(128, 64);
+        Can4Side2.mirror = true;
+        setRotation(Can4Side2, 0F, 0F, 0F);
+        Can3Side4 = new ModelRenderer(this, 0, 0);
+        Can3Side4.addBox(0F, 0F, 0F, 1, 2, 2);
+        Can3Side4.setRotationPoint(2F, 20F, -5F);
+        Can3Side4.setTextureSize(128, 64);
+        Can3Side4.mirror = true;
+        setRotation(Can3Side4, 0F, 0F, 0F);
+        Can4B = new ModelRenderer(this, 0, 0);
+        Can4B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4B.setRotationPoint(-6F, 22F, -6F);
+        Can4B.setTextureSize(128, 64);
+        Can4B.mirror = true;
+        setRotation(Can4B, 0F, 0F, 0F);
+        Can3Side2 = new ModelRenderer(this, 0, 0);
+        Can3Side2.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can3Side2.setRotationPoint(2F, 20F, -6F);
+        Can3Side2.setTextureSize(128, 64);
+        Can3Side2.mirror = true;
+        setRotation(Can3Side2, 0F, 0F, 0F);
+        Can3Side1 = new ModelRenderer(this, 0, 0);
+        Can3Side1.addBox(0F, 0F, 0F, 4, 2, 1);
+        Can3Side1.setRotationPoint(2F, 20F, -3F);
+        Can3Side1.setTextureSize(128, 64);
+        Can3Side1.mirror = true;
+        setRotation(Can3Side1, 0F, 0F, 0F);
+        Can2B = new ModelRenderer(this, 0, 0);
+        Can2B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2B.setRotationPoint(-6F, 22F, 2F);
+        Can2B.setTextureSize(128, 64);
+        Can2B.mirror = true;
+        setRotation(Can2B, 0F, 0F, 0F);
+        Can4T = new ModelRenderer(this, 0, 0);
+        Can4T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can4T.setRotationPoint(-6F, 19F, -6F);
+        Can4T.setTextureSize(128, 64);
+        Can4T.mirror = true;
+        setRotation(Can4T, 0F, 0F, 0F);
+        Can2T = new ModelRenderer(this, 0, 0);
+        Can2T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can2T.setRotationPoint(-6F, 19F, 2F);
+        Can2T.setTextureSize(128, 64);
+        Can2T.mirror = true;
+        setRotation(Can2T, 0F, 0F, 0F);
+        Can3T = new ModelRenderer(this, 0, 0);
+        Can3T.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3T.setRotationPoint(2F, 19F, -6F);
+        Can3T.setTextureSize(128, 64);
+        Can3T.mirror = true;
+        setRotation(Can3T, 0F, 0F, 0F);
+        Can3B = new ModelRenderer(this, 0, 0);
+        Can3B.addBox(0F, 0F, 0F, 4, 1, 4);
+        Can3B.setRotationPoint(2F, 22F, -6F);
+        Can3B.setTextureSize(128, 64);
+        Can3B.mirror = true;
+        setRotation(Can3B, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        MekanismRenderer.blendOn();
+
+        Base.render(size);
+        Base2.render(size);
+        IO1.render(size);
+        IO2.render(size);
+        IO3.render(size);
+        Base3.render(size);
+        Base4.render(size);
+        Base5.render(size);
+        Base6.render(size);
+        Can1B.render(size);
+        Can1T.render(size);
+        Can1Side3.render(size);
+        Can1Side1.render(size);
+        Can1Side2.render(size);
+        Can1Side4.render(size);
+        Can2Side4.render(size);
+        Can3Side3.render(size);
+        Can2Side2.render(size);
+        Can2Side3.render(size);
+        Can2Side1.render(size);
+        Can4Side3.render(size);
+        Can4Side1.render(size);
+        Can4Sjde4.render(size);
+        Can4Side2.render(size);
+        Can3Side4.render(size);
+        Can4B.render(size);
+        Can3Side2.render(size);
+        Can3Side1.render(size);
+        Can2B.render(size);
+        Can4T.render(size);
+        Can2T.render(size);
+        Can3T.render(size);
+        Can3B.render(size);
+
+        MekanismRenderer.blendOff();
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyChemicalWasher.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelDigitalMiner.java

@@ -0,0 +1,347 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.texture.TextureManager;
+
+public class LegacyModelDigitalMiner extends ModelMekanismBase implements IModelOnOff {
+    ModelRenderer Base;
+    ModelRenderer Back;
+    ModelRenderer Panel;
+    ModelRenderer PanelStem;
+    ModelRenderer KeyboardStem;
+    ModelRenderer Keyboard;
+    ModelRenderer LaserBase;
+    ModelRenderer LegRight;
+    ModelRenderer UpperLegRight;
+    ModelRenderer ToeTopRight1;
+    ModelRenderer ToeTopRight2;
+    ModelRenderer ToeRight1;
+    ModelRenderer LegHoldRight1;
+    ModelRenderer LegHoldRight2;
+    ModelRenderer FootBaseRight;
+    ModelRenderer ToeRight2;
+    ModelRenderer FootBaseLeft;
+    ModelRenderer UpperLegLeft;
+    ModelRenderer LegHoldLeft1;
+    ModelRenderer ToeTopLeft2;
+    ModelRenderer ToeTopLeft1;
+    ModelRenderer LegHoldLeft2;
+    ModelRenderer ToeLeft1;
+    ModelRenderer ToeLeft2;
+    ModelRenderer LegLeft;
+    ModelRenderer RightAxil;
+    ModelRenderer RightBackUpperLeg;
+    ModelRenderer RightBackLowerLeg;
+    ModelRenderer RightBackFoot;
+    ModelRenderer LeftAxil;
+    ModelRenderer LeftBackUpperLeg;
+    ModelRenderer LeftBackLowerLeg;
+    ModelRenderer LeftBackFoot;
+    ModelRenderer Laser1;
+    ModelRenderer Laser2;
+    ModelRenderer Laser3;
+    ModelRenderer Laser4;
+
+    public LegacyModelDigitalMiner() {
+        textureWidth = 256;
+        textureHeight = 256;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 18, 22, 20);
+        Base.setRotationPoint(-8F, -8F, -10F);
+        Base.setTextureSize(256, 256);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Back = new ModelRenderer(this, 77, 0);
+        Back.addBox(0F, 0F, 0F, 17, 20, 18);
+        Back.setRotationPoint(7F, -7F, -9F);
+        Back.setTextureSize(256, 256);
+        Back.mirror = true;
+        setRotation(Back, 0F, 0F, 0F);
+        Panel = new ModelRenderer(this, 0, 43);
+        Panel.addBox(-2F, -8F, -7.5F, 2, 12, 15);
+        Panel.setRotationPoint(-13F, 2F, 0F);
+        Panel.setTextureSize(256, 256);
+        Panel.mirror = true;
+        setRotation(Panel, 0F, 0F, -0.2478574F);
+        PanelStem = new ModelRenderer(this, 0, 71);
+        PanelStem.addBox(-7F, 0F, 0F, 7, 4, 4);
+        PanelStem.setRotationPoint(-7F, -2F, -2F);
+        PanelStem.setTextureSize(256, 256);
+        PanelStem.mirror = true;
+        setRotation(PanelStem, 0F, 0F, -0.2230717F);
+        KeyboardStem = new ModelRenderer(this, 0, 80);
+        KeyboardStem.addBox(-7F, 0F, -2F, 7, 1, 4);
+        KeyboardStem.setRotationPoint(-7F, 8F, 0F);
+        KeyboardStem.setTextureSize(256, 256);
+        KeyboardStem.mirror = true;
+        setRotation(KeyboardStem, 0F, 0F, -0.3965719F);
+        Keyboard = new ModelRenderer(this, 0, 86);
+        Keyboard.addBox(-5F, 0F, -5F, 5, 1, 10);
+        Keyboard.setRotationPoint(-12F, 10.5F, 0F);
+        Keyboard.setTextureSize(256, 256);
+        Keyboard.mirror = true;
+        setRotation(Keyboard, 0F, 0F, -0.2230717F);
+        LaserBase = new ModelRenderer(this, 0, 98);
+        LaserBase.addBox(0F, 0F, 0F, 10, 5, 10);
+        LaserBase.setRotationPoint(-5F, 12F, -5F);
+        LaserBase.setTextureSize(256, 256);
+        LaserBase.mirror = true;
+        setRotation(LaserBase, 0F, 0F, 0F);
+        LegRight = new ModelRenderer(this, 0, 114);
+        LegRight.addBox(0F, 0F, 0F, 6, 26, 4);
+        LegRight.setRotationPoint(-3F, -4F, -23F);
+        LegRight.setTextureSize(256, 256);
+        LegRight.mirror = true;
+        setRotation(LegRight, 0F, 0F, 0F);
+        UpperLegRight = new ModelRenderer(this, 21, 114);
+        UpperLegRight.addBox(0F, 0F, 0F, 4, 5, 13);
+        UpperLegRight.setRotationPoint(-2F, 0F, -22F);
+        UpperLegRight.setTextureSize(256, 256);
+        UpperLegRight.mirror = true;
+        setRotation(UpperLegRight, 0F, 0F, 0F);
+        ToeTopRight1 = new ModelRenderer(this, 21, 134);
+        ToeTopRight1.addBox(0F, 0F, 0F, 3, 1, 3);
+        ToeTopRight1.setRotationPoint(-4F, 19F, -20.5F);
+        ToeTopRight1.setTextureSize(256, 256);
+        ToeTopRight1.mirror = true;
+        setRotation(ToeTopRight1, 0F, 0F, 0F);
+        ToeTopRight2 = new ModelRenderer(this, 21, 134);
+        ToeTopRight2.addBox(0F, 0F, 0F, 3, 1, 3);
+        ToeTopRight2.setRotationPoint(1.5F, 19F, -20.5F);
+        ToeTopRight2.setTextureSize(256, 256);
+        ToeTopRight2.mirror = true;
+        setRotation(ToeTopRight2, 0F, 0F, 0F);
+        ToeRight1 = new ModelRenderer(this, 35, 134);
+        ToeRight1.addBox(0F, 0F, 0F, 3, 6, 3);
+        ToeRight1.setRotationPoint(1.5F, 22F, -20.5F);
+        ToeRight1.setTextureSize(256, 256);
+        ToeRight1.mirror = true;
+        setRotation(ToeRight1, 1.047198F, 0.3490659F, 0F);
+        LegHoldRight1 = new ModelRenderer(this, 0, 146);
+        LegHoldRight1.addBox(0F, 0F, 0F, 2, 3, 12);
+        LegHoldRight1.setRotationPoint(2F, 2F, -18F);
+        LegHoldRight1.setTextureSize(256, 256);
+        LegHoldRight1.mirror = true;
+        setRotation(LegHoldRight1, 0.6543436F, 0F, 0F);
+        LegHoldRight2 = new ModelRenderer(this, 0, 146);
+        LegHoldRight2.addBox(0F, 0F, 0F, 2, 3, 12);
+        LegHoldRight2.setRotationPoint(-4F, 2F, -18F);
+        LegHoldRight2.setTextureSize(256, 256);
+        LegHoldRight2.mirror = true;
+        setRotation(LegHoldRight2, 0.6543436F, 0F, 0F);
+        FootBaseRight = new ModelRenderer(this, 0, 162);
+        FootBaseRight.addBox(0F, 0F, 0F, 8, 2, 7);
+        FootBaseRight.setRotationPoint(-4F, 22F, -24F);
+        FootBaseRight.setTextureSize(256, 256);
+        FootBaseRight.mirror = true;
+        setRotation(FootBaseRight, 0F, 0F, 0F);
+        ToeRight2 = new ModelRenderer(this, 35, 134);
+        ToeRight2.addBox(0F, 0F, 0F, 3, 6, 3);
+        ToeRight2.setRotationPoint(-4.5F, 22F, -20.5F);
+        ToeRight2.setTextureSize(256, 256);
+        ToeRight2.mirror = true;
+        setRotation(ToeRight2, 1.047198F, -0.3490659F, 0F);
+        FootBaseLeft = new ModelRenderer(this, 0, 178);
+        FootBaseLeft.addBox(0F, 0F, 0F, 8, 2, 7);
+        FootBaseLeft.setRotationPoint(-4F, 22F, 17F);
+        FootBaseLeft.setTextureSize(256, 256);
+        FootBaseLeft.mirror = true;
+        setRotation(FootBaseLeft, 0F, 0F, 0F);
+        UpperLegLeft = new ModelRenderer(this, 0, 189);
+        UpperLegLeft.addBox(0F, 0F, 0F, 4, 5, 13);
+        UpperLegLeft.setRotationPoint(-2F, 0F, 9F);
+        UpperLegLeft.setTextureSize(256, 256);
+        UpperLegLeft.mirror = true;
+        setRotation(UpperLegLeft, 0F, 0F, 0F);
+        LegHoldLeft1 = new ModelRenderer(this, 0, 208);
+        LegHoldLeft1.addBox(0F, 0F, -12F, 2, 3, 12);
+        LegHoldLeft1.setRotationPoint(2F, 2F, 18F);
+        LegHoldLeft1.setTextureSize(256, 256);
+        LegHoldLeft1.mirror = true;
+        setRotation(LegHoldLeft1, -0.6543414F, 0F, 0F);
+        ToeTopLeft2 = new ModelRenderer(this, 31, 178);
+        ToeTopLeft2.addBox(0F, 0F, 0F, 3, 1, 3);
+        ToeTopLeft2.setRotationPoint(1.5F, 19F, 17.5F);
+        ToeTopLeft2.setTextureSize(256, 256);
+        ToeTopLeft2.mirror = true;
+        setRotation(ToeTopLeft2, 0F, 0F, 0F);
+        ToeTopLeft1 = new ModelRenderer(this, 31, 178);
+        ToeTopLeft1.addBox(0F, 0F, 0F, 3, 1, 3);
+        ToeTopLeft1.setRotationPoint(-4F, 19F, 17.5F);
+        ToeTopLeft1.setTextureSize(256, 256);
+        ToeTopLeft1.mirror = true;
+        setRotation(ToeTopLeft1, 0F, 0F, 0F);
+        LegHoldLeft2 = new ModelRenderer(this, 0, 208);
+        LegHoldLeft2.addBox(0F, 0F, -12F, 2, 3, 12);
+        LegHoldLeft2.setRotationPoint(-4F, 2F, 18F);
+        LegHoldLeft2.setTextureSize(256, 256);
+        LegHoldLeft2.mirror = true;
+        setRotation(LegHoldLeft2, -0.6543414F, 0F, 0F);
+        ToeLeft1 = new ModelRenderer(this, 44, 178);
+        ToeLeft1.addBox(0F, 0F, -3F, 3, 6, 3);
+        ToeLeft1.setRotationPoint(1.5F, 22F, 20.5F);
+        ToeLeft1.setTextureSize(256, 256);
+        ToeLeft1.mirror = true;
+        setRotation(ToeLeft1, -1.047198F, -0.3490659F, 0F);
+        ToeLeft2 = new ModelRenderer(this, 44, 178);
+        ToeLeft2.addBox(0F, 0F, -3F, 3, 6, 3);
+        ToeLeft2.setRotationPoint(-4.5F, 22F, 20.5F);
+        ToeLeft2.setTextureSize(256, 256);
+        ToeLeft2.mirror = true;
+        setRotation(ToeLeft2, -1.047198F, 0.3490659F, 0F);
+        LegLeft = new ModelRenderer(this, 35, 189);
+        LegLeft.addBox(0F, 0F, 0F, 6, 26, 4);
+        LegLeft.setRotationPoint(-3F, -4F, 19F);
+        LegLeft.setTextureSize(256, 256);
+        LegLeft.mirror = true;
+        setRotation(LegLeft, 0F, 0F, 0F);
+        RightAxil = new ModelRenderer(this, 78, 43);
+        RightAxil.addBox(0F, 0F, 0F, 4, 4, 6);
+        RightAxil.setRotationPoint(17F, 7F, -15F);
+        RightAxil.setTextureSize(256, 256);
+        RightAxil.mirror = true;
+        setRotation(RightAxil, 0F, 0F, 0F);
+        RightBackUpperLeg = new ModelRenderer(this, 78, 54);
+        RightBackUpperLeg.addBox(-2.5F, -3F, 0F, 5, 12, 1);
+        RightBackUpperLeg.setRotationPoint(19F, 9F, -15.95556F);
+        RightBackUpperLeg.setTextureSize(256, 256);
+        RightBackUpperLeg.mirror = true;
+        setRotation(RightBackUpperLeg, 0F, 0F, 0F);
+        RightBackLowerLeg = new ModelRenderer(this, 78, 68);
+        RightBackLowerLeg.addBox(-2F, 7F, -0.5F, 4, 6, 2);
+        RightBackLowerLeg.setRotationPoint(19F, 9F, -16F);
+        RightBackLowerLeg.setTextureSize(256, 256);
+        RightBackLowerLeg.mirror = true;
+        setRotation(RightBackLowerLeg, 0F, 0F, 0F);
+        RightBackFoot = new ModelRenderer(this, 99, 43);
+        RightBackFoot.addBox(-3F, 0F, -2.5F, 8, 2, 5);
+        RightBackFoot.setRotationPoint(19F, 22F, -15.5F);
+        RightBackFoot.setTextureSize(256, 256);
+        RightBackFoot.mirror = true;
+        setRotation(RightBackFoot, 0F, 0F, 0F);
+        LeftAxil = new ModelRenderer(this, 78, 80);
+        LeftAxil.addBox(0F, 0F, 0F, 4, 4, 6);
+        LeftAxil.setRotationPoint(17F, 7F, 9F);
+        LeftAxil.setTextureSize(256, 256);
+        LeftAxil.mirror = true;
+        setRotation(LeftAxil, 0F, 0F, 0F);
+        LeftBackUpperLeg = new ModelRenderer(this, 78, 91);
+        LeftBackUpperLeg.addBox(-2.5F, -3F, 0F, 5, 12, 1);
+        LeftBackUpperLeg.setRotationPoint(19F, 9F, 15.04444F);
+        LeftBackUpperLeg.setTextureSize(256, 256);
+        LeftBackUpperLeg.mirror = true;
+        setRotation(LeftBackUpperLeg, 0F, 0F, 0F);
+        LeftBackLowerLeg = new ModelRenderer(this, 78, 105);
+        LeftBackLowerLeg.addBox(-2F, 7F, -0.5F, 4, 6, 2);
+        LeftBackLowerLeg.setRotationPoint(19F, 9F, 15F);
+        LeftBackLowerLeg.setTextureSize(256, 256);
+        LeftBackLowerLeg.mirror = true;
+        setRotation(LeftBackLowerLeg, 0F, 0F, 0F);
+        LeftBackFoot = new ModelRenderer(this, 99, 80);
+        LeftBackFoot.addBox(-3F, 0F, -2.5F, 8, 2, 5);
+        LeftBackFoot.setRotationPoint(19F, 22F, 15.5F);
+        LeftBackFoot.setTextureSize(256, 256);
+        LeftBackFoot.mirror = true;
+        setRotation(LeftBackFoot, 0F, 0F, 0F);
+        Laser1 = new ModelRenderer(this, 35, 43);
+        Laser1.addBox(0F, 0F, 0F, 2, 4, 2);
+        Laser1.setRotationPoint(2.5F, 17F, 2.5F);
+        Laser1.setTextureSize(256, 256);
+        Laser1.mirror = true;
+        setRotation(Laser1, 0F, 0F, 0F);
+        Laser2 = new ModelRenderer(this, 35, 43);
+        Laser2.addBox(0F, 0F, 0F, 2, 4, 2);
+        Laser2.setRotationPoint(2.5F, 17F, -4.5F);
+        Laser2.setTextureSize(256, 256);
+        Laser2.mirror = true;
+        setRotation(Laser2, 0F, 0F, 0F);
+        Laser3 = new ModelRenderer(this, 35, 43);
+        Laser3.addBox(0F, 0F, 0F, 2, 4, 2);
+        Laser3.setRotationPoint(-4.5F, 17F, 2.5F);
+        Laser3.setTextureSize(256, 256);
+        Laser3.mirror = true;
+        setRotation(Laser3, 0F, 0F, 0F);
+        Laser4 = new ModelRenderer(this, 35, 43);
+        Laser4.addBox(0F, 0F, 0F, 2, 4, 2);
+        Laser4.setRotationPoint(-4.5F, 17F, -4.5F);
+        Laser4.setTextureSize(256, 256);
+        Laser4.mirror = true;
+        setRotation(Laser4, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size, boolean on, TextureManager manager) {
+        Base.render(size);
+        Back.render(size);
+
+        if (on) {
+            MekanismRenderer.glowOn();
+        }
+
+        Panel.render(size);
+
+        if (on) {
+            MekanismRenderer.glowOff();
+        }
+
+        PanelStem.render(size);
+        KeyboardStem.render(size);
+        Keyboard.render(size);
+        LaserBase.render(size);
+        LegRight.render(size);
+        UpperLegRight.render(size);
+        ToeTopRight1.render(size);
+        ToeTopRight2.render(size);
+        ToeRight1.render(size);
+        LegHoldRight1.render(size);
+        LegHoldRight2.render(size);
+        FootBaseRight.render(size);
+        ToeRight2.render(size);
+        FootBaseLeft.render(size);
+        UpperLegLeft.render(size);
+        LegHoldLeft1.render(size);
+        ToeTopLeft2.render(size);
+        ToeTopLeft1.render(size);
+        LegHoldLeft2.render(size);
+        ToeLeft1.render(size);
+        ToeLeft2.render(size);
+        LegLeft.render(size);
+        RightAxil.render(size);
+        RightBackUpperLeg.render(size);
+        RightBackLowerLeg.render(size);
+        RightBackFoot.render(size);
+        LeftAxil.render(size);
+        LeftBackUpperLeg.render(size);
+        LeftBackLowerLeg.render(size);
+        LeftBackFoot.render(size);
+        Laser1.render(size);
+        Laser2.render(size);
+        Laser3.render(size);
+        Laser4.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyDigitalMiner.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return on ? "LegacyDigitalMinerOn.png" : this.getTextureName();
+    }
+
+    @Override
+    public void render(float size) {
+        this.render(size, false, Minecraft.getMinecraft().renderEngine);
+    }
+}

src/main/java/mekanism/client/model/LegacyModelElectricPump.java

@@ -0,0 +1,124 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelElectricPump extends ModelMekanismBase {
+    ModelRenderer PumpHead;
+    ModelRenderer Connector;
+    ModelRenderer Panel1;
+    ModelRenderer Panel2;
+    ModelRenderer Panel3;
+    ModelRenderer Body;
+    ModelRenderer Axil;
+    ModelRenderer Axil2;
+    ModelRenderer Ring1;
+    ModelRenderer Ring2;
+    ModelRenderer Plug;
+    ModelRenderer Ring3;
+
+    public LegacyModelElectricPump() {
+        textureWidth = 64;
+        textureHeight = 64;
+
+        PumpHead = new ModelRenderer(this, 33, 0);
+        PumpHead.addBox(0F, 0F, 0F, 6, 3, 6);
+        PumpHead.setRotationPoint(-3F, 19F, -3F);
+        PumpHead.setTextureSize(64, 64);
+        PumpHead.mirror = true;
+        setRotation(PumpHead, 0F, 0F, 0F);
+        Connector = new ModelRenderer(this, 33, 10);
+        Connector.addBox(0F, 0F, 0F, 4, 1, 5);
+        Connector.setRotationPoint(-2F, 14F, 2.5F);
+        Connector.setTextureSize(64, 64);
+        Connector.mirror = true;
+        setRotation(Connector, 0F, 0F, 0F);
+        Panel1 = new ModelRenderer(this, 0, 15);
+        Panel1.addBox(-3F, -6F, 0F, 6, 6, 1);
+        Panel1.setRotationPoint(0F, 21F, -3F);
+        Panel1.setTextureSize(64, 64);
+        Panel1.mirror = true;
+        setRotation(Panel1, 0.5585054F, 0F, 0F);
+        Panel2 = new ModelRenderer(this, 15, 15);
+        Panel2.addBox(0F, -6F, -3F, 1, 6, 6);
+        Panel2.setRotationPoint(-3F, 21F, 0F);
+        Panel2.setTextureSize(64, 64);
+        Panel2.mirror = true;
+        setRotation(Panel2, 0F, 0F, -0.5585054F);
+        Panel3 = new ModelRenderer(this, 15, 15);
+        Panel3.addBox(-1F, -6F, -3F, 1, 6, 6);
+        Panel3.setRotationPoint(3F, 21F, 0F);
+        Panel3.setTextureSize(64, 64);
+        Panel3.mirror = true;
+        setRotation(Panel3, 0F, 0F, 0.5585054F);
+        Body = new ModelRenderer(this, 30, 17);
+        Body.addBox(0F, 0F, 0F, 6, 10, 6);
+        Body.setRotationPoint(-3F, 9F, -3F);
+        Body.setTextureSize(64, 64);
+        Body.mirror = true;
+        setRotation(Body, 0F, 0F, 0F);
+        Axil = new ModelRenderer(this, 0, 28);
+        Axil.addBox(0F, 0F, 0F, 9, 2, 4);
+        Axil.setRotationPoint(-4.5F, 17F, -2F);
+        Axil.setTextureSize(64, 64);
+        Axil.mirror = true;
+        setRotation(Axil, 0F, 0F, 0F);
+        Axil2 = new ModelRenderer(this, 0, 0);
+        Axil2.addBox(0F, 0F, 0F, 4, 2, 12);
+        Axil2.setRotationPoint(-2F, 17F, -4.5F);
+        Axil2.setTextureSize(64, 64);
+        Axil2.mirror = true;
+        setRotation(Axil2, 0F, 0F, 0F);
+        Ring1 = new ModelRenderer(this, 0, 35);
+        Ring1.addBox(0F, 0F, 0F, 8, 1, 8);
+        Ring1.setRotationPoint(-4F, 12F, -4F);
+        Ring1.setTextureSize(64, 64);
+        Ring1.mirror = true;
+        setRotation(Ring1, 0F, 0F, 0F);
+        Ring2 = new ModelRenderer(this, 0, 35);
+        Ring2.addBox(0F, 0F, 0F, 8, 1, 8);
+        Ring2.setRotationPoint(-4F, 10F, -4F);
+        Ring2.setTextureSize(64, 64);
+        Ring2.mirror = true;
+        setRotation(Ring2, 0F, 0F, 0F);
+        Plug = new ModelRenderer(this, 0, 45);
+        Plug.addBox(0F, 0F, 0F, 6, 6, 1);
+        Plug.setRotationPoint(-3F, 13F, 7F);
+        Plug.setTextureSize(64, 64);
+        Plug.mirror = true;
+        setRotation(Plug, 0F, 0F, 0F);
+        Ring3 = new ModelRenderer(this, 0, 35);
+        Ring3.addBox(0F, 0F, 0F, 8, 1, 8);
+        Ring3.setRotationPoint(-4F, 8F, -4F);
+        Ring3.setTextureSize(64, 64);
+        Ring3.mirror = true;
+        setRotation(Ring3, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        PumpHead.render(size);
+        Connector.render(size);
+        Panel1.render(size);
+        Panel2.render(size);
+        Panel3.render(size);
+        Body.render(size);
+        Axil.render(size);
+        Axil2.render(size);
+        Ring1.render(size);
+        Ring2.render(size);
+        Plug.render(size);
+        Ring3.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyElectricPump.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelElectrolyticSeparator.java

@@ -0,0 +1,204 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelElectrolyticSeparator extends ModelMekanismBase {
+    ModelRenderer A;
+    ModelRenderer B;
+    ModelRenderer C;
+    ModelRenderer D;
+    ModelRenderer E;
+    ModelRenderer F;
+    ModelRenderer G;
+    ModelRenderer H;
+    ModelRenderer I;
+    ModelRenderer J;
+    ModelRenderer K;
+    ModelRenderer L;
+    ModelRenderer M;
+    ModelRenderer N;
+    ModelRenderer OUTPUT;
+    ModelRenderer P;
+    ModelRenderer Q;
+    ModelRenderer R;
+    ModelRenderer S;
+    ModelRenderer T;
+    ModelRenderer U;
+    ModelRenderer V;
+
+    public LegacyModelElectrolyticSeparator() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        A = new ModelRenderer(this, 0, 0);
+        A.addBox(-8F, 0F, -8F, 16, 1, 16);
+        A.setRotationPoint(0F, 23F, 0F);
+        A.setTextureSize(128, 128);
+        A.mirror = true;
+        setRotation(A, 0F, 0F, 0F);
+        B = new ModelRenderer(this, 85, 0);
+        B.addBox(-2F, 0F, -2F, 4, 10, 4);
+        B.setRotationPoint(4F, 12F, -4F);
+        B.setTextureSize(128, 128);
+        B.mirror = true;
+        setRotation(B, 0F, 1.570796F, 0F);
+        C = new ModelRenderer(this, 66, 0);
+        C.addBox(-2F, 0F, -2F, 4, 10, 4);
+        C.setRotationPoint(-4F, 12F, -4F);
+        C.setTextureSize(128, 128);
+        C.mirror = true;
+        setRotation(C, 0F, 1.570796F, 0F);
+        D = new ModelRenderer(this, 48, 19);
+        D.addBox(-1F, -1F, 0F, 2, 2, 6);
+        D.setRotationPoint(-2F, 18F, -4F);
+        D.setTextureSize(128, 128);
+        D.mirror = true;
+        setRotation(D, 0F, 1.570796F, 0F);
+        E = new ModelRenderer(this, 0, 19);
+        E.addBox(0F, 0F, -6F, 4, 15, 14);
+        E.setRotationPoint(0F, 8F, 8F);
+        E.setTextureSize(128, 128);
+        E.mirror = true;
+        setRotation(E, 0F, 1.570796F, 0F);
+        F = new ModelRenderer(this, 103, 0);
+        F.addBox(-3F, -1F, -1F, 6, 2, 2);
+        F.setRotationPoint(4F, 20F, 1F);
+        F.setTextureSize(128, 128);
+        F.mirror = true;
+        setRotation(F, 0F, 1.570796F, 0F);
+        G = new ModelRenderer(this, 103, 0);
+        G.addBox(-3F, 0F, 0F, 6, 2, 2);
+        G.setRotationPoint(-5F, 20F, 1F);
+        G.setTextureSize(128, 128);
+        G.mirror = true;
+        setRotation(G, 0F, 1.570796F, 0F);
+        H = new ModelRenderer(this, 0, 50);
+        H.addBox(-2F, 0F, 0F, 4, 12, 2);
+        H.setRotationPoint(-8F, 11F, 6F);
+        H.setTextureSize(128, 128);
+        H.mirror = true;
+        setRotation(H, 0F, 1.570796F, 0F);
+        I = new ModelRenderer(this, 41, 28);
+        I.addBox(0F, 0F, 0F, 6, 1, 6);
+        I.setRotationPoint(-7F, 22F, -7F);
+        I.setTextureSize(128, 128);
+        I.mirror = true;
+        setRotation(I, 0F, 0F, 0F);
+        J = new ModelRenderer(this, 41, 28);
+        J.addBox(0F, 0F, 0F, 6, 1, 6);
+        J.setRotationPoint(1F, 22F, -7F);
+        J.setTextureSize(128, 128);
+        J.mirror = true;
+        setRotation(J, 0F, 0F, 0F);
+        K = new ModelRenderer(this, 66, 16);
+        K.addBox(0F, 0F, 0F, 2, 1, 2);
+        K.setRotationPoint(-5F, 11F, -5F);
+        K.setTextureSize(128, 128);
+        K.mirror = true;
+        setRotation(K, 0F, 0F, 0F);
+        L = new ModelRenderer(this, 85, 15);
+        L.addBox(0F, 0F, 0F, 2, 2, 2);
+        L.setRotationPoint(3F, 10F, -5F);
+        L.setTextureSize(128, 128);
+        L.mirror = true;
+        setRotation(L, 0F, 0F, 0F);
+        M = new ModelRenderer(this, 66, 22);
+        M.addBox(-1F, 0F, -1F, 2, 2, 6);
+        M.setRotationPoint(-4F, 9F, -4F);
+        M.setTextureSize(128, 128);
+        M.mirror = true;
+        setRotation(M, 0F, 1.570796F, 0F);
+        N = new ModelRenderer(this, 66, 32);
+        N.addBox(-1F, -1F, -1F, 2, 6, 2);
+        N.setRotationPoint(0F, 12F, -4F);
+        N.setTextureSize(128, 128);
+        N.mirror = true;
+        setRotation(N, 0F, 0F, 0F);
+        OUTPUT = new ModelRenderer(this, 66, 42);
+        OUTPUT.addBox(-1F, -1F, -1F, 4, 2, 2);
+        OUTPUT.setRotationPoint(0F, 16F, -5F);
+        OUTPUT.setTextureSize(128, 128);
+        OUTPUT.mirror = true;
+        setRotation(OUTPUT, 0F, 1.570796F, 0F);
+        P = new ModelRenderer(this, 85, 21);
+        P.addBox(-1F, -1F, -1F, 2, 3, 2);
+        P.setRotationPoint(5F, 9F, -4F);
+        P.setTextureSize(128, 128);
+        P.mirror = true;
+        setRotation(P, 0F, 0F, 0.6457718F);
+        Q = new ModelRenderer(this, 0, 65);
+        Q.addBox(0F, 0F, -2F, 3, 11, 6);
+        Q.setRotationPoint(-8F, 12F, 0F);
+        Q.setTextureSize(128, 128);
+        Q.mirror = true;
+        setRotation(Q, 0F, 0F, 0F);
+        R = new ModelRenderer(this, 0, 65);
+        R.addBox(0F, 0F, -3F, 3, 11, 6);
+        R.setRotationPoint(8F, 12F, 1F);
+        R.setTextureSize(128, 128);
+        R.mirror = true;
+        setRotation(R, 0F, 3.141593F, 0F);
+        S = new ModelRenderer(this, 0, 84);
+        S.addBox(0F, 0F, 0F, 4, 1, 1);
+        S.setRotationPoint(2F, 16F, 3F);
+        S.setTextureSize(128, 128);
+        S.mirror = true;
+        setRotation(S, 0F, 0F, 0F);
+        T = new ModelRenderer(this, 0, 84);
+        T.addBox(0F, 0F, 0F, 4, 1, 1);
+        T.setRotationPoint(-6F, 16F, 3F);
+        T.setTextureSize(128, 128);
+        T.mirror = true;
+        setRotation(T, 0F, 0F, 0F);
+        U = new ModelRenderer(this, 0, 87);
+        U.addBox(0F, 0F, 0F, 4, 1, 1);
+        U.setRotationPoint(-6F, 18F, 3F);
+        U.setTextureSize(128, 128);
+        U.mirror = true;
+        setRotation(U, 0F, 0F, 0F);
+        V = new ModelRenderer(this, 0, 87);
+        V.addBox(0F, 0F, 0F, 4, 1, 1);
+        V.setRotationPoint(2F, 18F, 3F);
+        V.setTextureSize(128, 128);
+        V.mirror = true;
+        setRotation(V, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        A.render(size);
+        B.render(size);
+        C.render(size);
+        D.render(size);
+        E.render(size);
+        F.render(size);
+        G.render(size);
+        H.render(size);
+        I.render(size);
+        J.render(size);
+        K.render(size);
+        L.render(size);
+        M.render(size);
+        N.render(size);
+        OUTPUT.render(size);
+        P.render(size);
+        Q.render(size);
+        R.render(size);
+        S.render(size);
+        T.render(size);
+        U.render(size);
+        V.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyElectrolyticSeparator.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelEnergyCube.java

@@ -0,0 +1,245 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import mekanism.common.SideData.IOState;
+import mekanism.common.Tier.BaseTier;
+import mekanism.common.Tier.EnergyCubeTier;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class LegacyModelEnergyCube extends ModelMekanismBase implements IModelEnergyCube {
+    ModelRenderer Corner1;
+    ModelRenderer Corner2;
+    ModelRenderer Corner3;
+    ModelRenderer Corner4;
+    ModelRenderer Corner5;
+    ModelRenderer Corner6;
+    ModelRenderer Corner7;
+    ModelRenderer Corner8;
+    ModelRenderer Frame4;
+    ModelRenderer Frame3;
+    ModelRenderer Frame2;
+    ModelRenderer Frame1;
+    ModelRenderer Connection;
+    ModelRenderer HoriPole1;
+    ModelRenderer HoriPole2;
+    ModelRenderer HoriPole3;
+    ModelRenderer HoriPole4;
+    ModelRenderer HoriPole5;
+    ModelRenderer HoriPole6;
+    ModelRenderer HoriPole7;
+    ModelRenderer HoriPole8;
+
+    public LegacyModelEnergyCube() {
+        textureWidth = 64;
+        textureHeight = 64;
+
+        Corner1 = new ModelRenderer(this, 0, 17);
+        Corner1.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner1.setRotationPoint(5F, 21F, -8F);
+        Corner1.setTextureSize(64, 64);
+        Corner1.mirror = true;
+        setRotation(Corner1, 0F, 0F, 0F);
+        Corner2 = new ModelRenderer(this, 0, 17);
+        Corner2.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner2.setRotationPoint(-8F, 21F, -8F);
+        Corner2.setTextureSize(64, 64);
+        Corner2.mirror = true;
+        setRotation(Corner2, 0F, 0F, 0F);
+        Corner3 = new ModelRenderer(this, 0, 17);
+        Corner3.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner3.setRotationPoint(5F, 21F, 5F);
+        Corner3.setTextureSize(64, 64);
+        Corner3.mirror = true;
+        setRotation(Corner3, 0F, 0F, 0F);
+        Corner4 = new ModelRenderer(this, 0, 17);
+        Corner4.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner4.setRotationPoint(-8F, 21F, 5F);
+        Corner4.setTextureSize(64, 64);
+        Corner4.mirror = true;
+        setRotation(Corner4, 0F, 0F, 0F);
+        Corner5 = new ModelRenderer(this, 0, 17);
+        Corner5.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner5.setRotationPoint(5F, 8F, -8F);
+        Corner5.setTextureSize(64, 64);
+        Corner5.mirror = true;
+        setRotation(Corner5, 0F, 0F, 0F);
+        Corner6 = new ModelRenderer(this, 0, 17);
+        Corner6.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner6.setRotationPoint(-8F, 8F, -8F);
+        Corner6.setTextureSize(64, 64);
+        Corner6.mirror = true;
+        setRotation(Corner6, 0F, 0F, 0F);
+        Corner7 = new ModelRenderer(this, 0, 17);
+        Corner7.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner7.setRotationPoint(-8F, 8F, 5F);
+        Corner7.setTextureSize(64, 64);
+        Corner7.mirror = true;
+        setRotation(Corner7, 0F, 0F, 0F);
+        Corner8 = new ModelRenderer(this, 0, 17);
+        Corner8.addBox(0F, 0F, 0F, 3, 3, 3);
+        Corner8.setRotationPoint(5F, 8F, 5F);
+        Corner8.setTextureSize(64, 64);
+        Corner8.mirror = true;
+        setRotation(Corner8, 0F, 0F, 0F);
+        Frame4 = new ModelRenderer(this, 0, 24);
+        Frame4.addBox(0F, 0F, 0F, 3, 10, 3);
+        Frame4.setRotationPoint(5F, 11F, -8F);
+        Frame4.setTextureSize(64, 64);
+        Frame4.mirror = true;
+        setRotation(Frame4, 0F, 0F, 0F);
+        Frame3 = new ModelRenderer(this, 0, 24);
+        Frame3.addBox(0F, 0F, 0F, 3, 10, 3);
+        Frame3.setRotationPoint(-8F, 11F, -8F);
+        Frame3.setTextureSize(64, 64);
+        Frame3.mirror = true;
+        setRotation(Frame3, 0F, 0F, 0F);
+        Frame2 = new ModelRenderer(this, 0, 24);
+        Frame2.addBox(0F, 0F, 0F, 3, 10, 3);
+        Frame2.setRotationPoint(-8F, 11F, 5F);
+        Frame2.setTextureSize(64, 64);
+        Frame2.mirror = true;
+        setRotation(Frame2, 0F, 0F, 0F);
+        Frame1 = new ModelRenderer(this, 0, 24);
+        Frame1.addBox(0F, 0F, 0F, 3, 10, 3);
+        Frame1.setRotationPoint(5F, 11F, 5F);
+        Frame1.setTextureSize(64, 64);
+        Frame1.mirror = true;
+        setRotation(Frame1, 0F, 0F, 0F);
+        Connection = new ModelRenderer(this, 0, 7);
+        Connection.addBox(0F, 0F, 0F, 10, 6, 1);
+        Connection.setRotationPoint(-5F, 13F, -8F);
+        Connection.setTextureSize(64, 64);
+        Connection.mirror = true;
+        setRotation(Connection, 0F, 0F, 0F);
+        HoriPole1 = new ModelRenderer(this, 27, 0);
+        HoriPole1.addBox(0F, 0F, 0F, 3, 3, 10);
+        HoriPole1.setRotationPoint(5F, 21F, -5F);
+        HoriPole1.setTextureSize(64, 64);
+        HoriPole1.mirror = true;
+        setRotation(HoriPole1, 0F, 0F, 0F);
+        HoriPole2 = new ModelRenderer(this, 0, 0);
+        HoriPole2.addBox(0F, 0F, 0F, 10, 3, 3);
+        HoriPole2.setRotationPoint(-5F, 21F, 5F);
+        HoriPole2.setTextureSize(64, 64);
+        HoriPole2.mirror = true;
+        setRotation(HoriPole2, 0F, 0F, 0F);
+        HoriPole3 = new ModelRenderer(this, 27, 0);
+        HoriPole3.addBox(0F, 0F, 0F, 3, 3, 10);
+        HoriPole3.setRotationPoint(-8F, 21F, -5F);
+        HoriPole3.setTextureSize(64, 64);
+        HoriPole3.mirror = true;
+        setRotation(HoriPole3, 0F, 0F, 0F);
+        HoriPole4 = new ModelRenderer(this, 0, 0);
+        HoriPole4.addBox(0F, 0F, 0F, 10, 3, 3);
+        HoriPole4.setRotationPoint(-5F, 21F, -8F);
+        HoriPole4.setTextureSize(64, 64);
+        HoriPole4.mirror = true;
+        setRotation(HoriPole4, 0F, 0F, 0F);
+        HoriPole5 = new ModelRenderer(this, 27, 0);
+        HoriPole5.addBox(0F, 0F, 0F, 3, 3, 10);
+        HoriPole5.setRotationPoint(5F, 8F, -5F);
+        HoriPole5.setTextureSize(64, 64);
+        HoriPole5.mirror = true;
+        setRotation(HoriPole5, 0F, 0F, 0F);
+        HoriPole6 = new ModelRenderer(this, 0, 0);
+        HoriPole6.addBox(0F, 0F, 0F, 10, 3, 3);
+        HoriPole6.setRotationPoint(-5F, 8F, 5F);
+        HoriPole6.setTextureSize(64, 64);
+        HoriPole6.mirror = true;
+        setRotation(HoriPole6, 0F, 0F, 0F);
+        HoriPole7 = new ModelRenderer(this, 27, 0);
+        HoriPole7.addBox(0F, 0F, 0F, 3, 3, 10);
+        HoriPole7.setRotationPoint(-8F, 8F, -5F);
+        HoriPole7.setTextureSize(64, 64);
+        HoriPole7.mirror = true;
+        setRotation(HoriPole7, 0F, 0F, 0F);
+        HoriPole8 = new ModelRenderer(this, 0, 0);
+        HoriPole8.addBox(0F, 0F, 0F, 10, 3, 3);
+        HoriPole8.setRotationPoint(-5F, 8F, -8F);
+        HoriPole8.setTextureSize(64, 64);
+        HoriPole8.mirror = true;
+        setRotation(HoriPole8, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        MekanismRenderer.glowOn();
+        Corner1.render(size);
+        Corner2.render(size);
+        Corner3.render(size);
+        Corner4.render(size);
+        Corner5.render(size);
+        Corner6.render(size);
+        Corner7.render(size);
+        Corner8.render(size);
+        MekanismRenderer.glowOff();
+
+        Frame4.render(size);
+        Frame3.render(size);
+        Frame2.render(size);
+        Frame1.render(size);
+        Connection.render(size);
+        HoriPole1.render(size);
+        HoriPole2.render(size);
+        HoriPole3.render(size);
+        HoriPole4.render(size);
+        HoriPole5.render(size);
+        HoriPole6.render(size);
+        HoriPole7.render(size);
+        HoriPole8.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return this.getTextureNameForTier(BaseTier.BASIC);
+    }
+
+    @Override
+    public String getTextureNameForTier(BaseTier tier) {
+        return "LegacyEnergyCube" + tier.getName() + ".png";
+    }
+
+    public static class LegacyModelEnergyCore extends ModelMekanismBase {
+        private ModelRenderer cube;
+
+        public LegacyModelEnergyCore() {
+            textureWidth = 32;
+            textureHeight = 32;
+
+            cube = new ModelRenderer(this, 0, 0);
+            cube.addBox(-8, -8, -8, 16, 16, 16);
+            cube.setTextureSize(32, 32);
+            cube.mirror = true;
+        }
+
+        @Override
+        public void render(float size) {
+            cube.render(0.0625F);
+        }
+
+        @Override
+        public String getTextureName() {
+            return "EnergyCore.png";
+        }
+    }
+
+    @Override
+    public void renderSide(
+        float size,
+        ForgeDirection side,
+        IOState state,
+        EnergyCubeTier tier,
+        TextureManager renderer
+    ) {
+        // not used for the legacy model
+    }
+}

src/main/java/mekanism/client/model/LegacyModelFluidicPlenisher.java

@@ -0,0 +1,148 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelFluidicPlenisher extends ModelMekanismBase {
+    ModelRenderer PumpBase;
+    ModelRenderer PumpTube;
+    ModelRenderer CoreStart;
+    ModelRenderer Core;
+    ModelRenderer FluidOutput;
+    ModelRenderer EnergyInput;
+    ModelRenderer EnergyTube;
+    ModelRenderer Screen;
+    ModelRenderer Keyboard;
+    ModelRenderer RightThing;
+    ModelRenderer LeftThing;
+    ModelRenderer RightCable;
+    ModelRenderer LeftCable;
+    ModelRenderer LeftConnector;
+    ModelRenderer RightConnector;
+
+    public LegacyModelFluidicPlenisher() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        PumpBase = new ModelRenderer(this, 0, 29);
+        PumpBase.addBox(0F, 0F, 0F, 6, 1, 6);
+        PumpBase.setRotationPoint(-3F, 23F, -3F);
+        PumpBase.setTextureSize(128, 128);
+        PumpBase.mirror = true;
+        setRotation(PumpBase, 0F, 0F, 0F);
+        PumpTube = new ModelRenderer(this, 40, 5);
+        PumpTube.addBox(0F, 0F, 0F, 2, 3, 2);
+        PumpTube.setRotationPoint(-1F, 20F, -1F);
+        PumpTube.setTextureSize(128, 128);
+        PumpTube.mirror = true;
+        setRotation(PumpTube, 0F, 0F, 0F);
+        CoreStart = new ModelRenderer(this, 40, 0);
+        CoreStart.addBox(0F, 0F, 0F, 4, 1, 4);
+        CoreStart.setRotationPoint(-2F, 19F, -2F);
+        CoreStart.setTextureSize(128, 128);
+        CoreStart.mirror = true;
+        setRotation(CoreStart, 0F, 0F, 0F);
+        Core = new ModelRenderer(this, 0, 0);
+        Core.addBox(0F, 0F, 0F, 10, 8, 10);
+        Core.setRotationPoint(-5F, 11F, -5F);
+        Core.setTextureSize(128, 128);
+        Core.mirror = true;
+        setRotation(Core, 0F, 0F, 0F);
+        FluidOutput = new ModelRenderer(this, 0, 18);
+        FluidOutput.addBox(0F, 0F, 0F, 8, 3, 8);
+        FluidOutput.setRotationPoint(-4F, 8F, -4F);
+        FluidOutput.setTextureSize(128, 128);
+        FluidOutput.mirror = true;
+        setRotation(FluidOutput, 0F, 0F, 0F);
+        EnergyInput = new ModelRenderer(this, 0, 36);
+        EnergyInput.addBox(0F, 0F, 0F, 6, 6, 1);
+        EnergyInput.setRotationPoint(-3F, 13F, 7F);
+        EnergyInput.setTextureSize(128, 128);
+        EnergyInput.mirror = true;
+        setRotation(EnergyInput, 0F, 0F, 0F);
+        EnergyTube = new ModelRenderer(this, 14, 36);
+        EnergyTube.addBox(0F, 0F, 0F, 2, 2, 2);
+        EnergyTube.setRotationPoint(-1F, 15F, 5F);
+        EnergyTube.setTextureSize(128, 128);
+        EnergyTube.mirror = true;
+        setRotation(EnergyTube, 0F, 0F, 0F);
+        Screen = new ModelRenderer(this, 40, 17);
+        Screen.addBox(0F, 0F, 0F, 8, 5, 1);
+        Screen.setRotationPoint(-4F, 12F, -6F);
+        Screen.setTextureSize(128, 128);
+        Screen.mirror = true;
+        setRotation(Screen, 0F, 0F, 0F);
+        Keyboard = new ModelRenderer(this, 40, 13);
+        Keyboard.addBox(0F, 0F, 0F, 8, 1, 3);
+        Keyboard.setRotationPoint(-4F, 17F, -8F);
+        Keyboard.setTextureSize(128, 128);
+        Keyboard.mirror = true;
+        setRotation(Keyboard, 0.3490659F, 0F, 0F);
+        RightThing = new ModelRenderer(this, 24, 29);
+        RightThing.addBox(0F, 0F, 0F, 1, 4, 4);
+        RightThing.setRotationPoint(-6F, 13F, -2F);
+        RightThing.setTextureSize(128, 128);
+        RightThing.mirror = true;
+        setRotation(RightThing, 0F, 0F, 0F);
+        LeftThing = new ModelRenderer(this, 24, 29);
+        LeftThing.addBox(0F, 0F, 0F, 1, 4, 4);
+        LeftThing.setRotationPoint(5F, 13F, -2F);
+        LeftThing.setTextureSize(128, 128);
+        LeftThing.mirror = true;
+        setRotation(LeftThing, 0F, 0F, 0F);
+        RightCable = new ModelRenderer(this, 32, 18);
+        RightCable.addBox(0F, 0F, 0F, 1, 3, 2);
+        RightCable.setRotationPoint(-6F, 17F, -1F);
+        RightCable.setTextureSize(128, 128);
+        RightCable.mirror = true;
+        setRotation(RightCable, 0F, 0F, 0F);
+        LeftCable = new ModelRenderer(this, 32, 18);
+        LeftCable.addBox(0F, 0F, 0F, 1, 3, 2);
+        LeftCable.setRotationPoint(5F, 17F, -1F);
+        LeftCable.setTextureSize(128, 128);
+        LeftCable.mirror = true;
+        setRotation(LeftCable, 0F, 0F, 0F);
+        LeftConnector = new ModelRenderer(this, 40, 10);
+        LeftConnector.addBox(0F, 0F, 0F, 3, 1, 2);
+        LeftConnector.setRotationPoint(2F, 19F, -1F);
+        LeftConnector.setTextureSize(128, 128);
+        LeftConnector.mirror = true;
+        setRotation(LeftConnector, 0F, 0F, 0F);
+        RightConnector = new ModelRenderer(this, 40, 10);
+        RightConnector.addBox(0F, 0F, 0F, 3, 1, 2);
+        RightConnector.setRotationPoint(-5F, 19F, -1F);
+        RightConnector.setTextureSize(128, 128);
+        RightConnector.mirror = true;
+        setRotation(RightConnector, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        PumpBase.render(size);
+        PumpTube.render(size);
+        CoreStart.render(size);
+        Core.render(size);
+        FluidOutput.render(size);
+        EnergyInput.render(size);
+        EnergyTube.render(size);
+        Screen.render(size);
+        Keyboard.render(size);
+        RightThing.render(size);
+        LeftThing.render(size);
+        RightCable.render(size);
+        LeftCable.render(size);
+        LeftConnector.render(size);
+        RightConnector.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyFluidicPlenisher.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelGasTank.java

@@ -0,0 +1,90 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.common.Tier.BaseTier;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelGasTank extends ModelMekanismBase implements IModelTier {
+    ModelRenderer Panel1;
+    ModelRenderer Panel2;
+    ModelRenderer Panel3;
+    ModelRenderer Tank;
+    ModelRenderer Panel4;
+    ModelRenderer Top;
+    ModelRenderer Exit;
+
+    public LegacyModelGasTank() {
+        textureWidth = 32;
+        textureHeight = 64;
+
+        Panel1 = new ModelRenderer(this, 0, 22);
+        Panel1.addBox(0F, 0F, 0F, 5, 13, 1);
+        Panel1.setRotationPoint(-2.5F, 11F, 3.5F);
+        Panel1.setTextureSize(32, 64);
+        Panel1.mirror = true;
+        setRotation(Panel1, 0F, 0F, 0F);
+        Panel2 = new ModelRenderer(this, 0, 37);
+        Panel2.addBox(0F, 0F, 0F, 1, 13, 5);
+        Panel2.setRotationPoint(3.5F, 11F, -2.5F);
+        Panel2.setTextureSize(32, 64);
+        Panel2.mirror = true;
+        setRotation(Panel2, 0F, 0F, 0F);
+        Panel3 = new ModelRenderer(this, 0, 22);
+        Panel3.addBox(0F, 0F, 0F, 5, 13, 1);
+        Panel3.setRotationPoint(-2.5F, 11F, -4.5F);
+        Panel3.setTextureSize(32, 64);
+        Panel3.mirror = true;
+        setRotation(Panel3, 0F, 0F, 0F);
+        Tank = new ModelRenderer(this, 0, 0);
+        Tank.addBox(0F, 0F, 0F, 7, 14, 7);
+        Tank.setRotationPoint(-3.5F, 10F, -3.5F);
+        Tank.setTextureSize(32, 64);
+        Tank.mirror = true;
+        setRotation(Tank, 0F, 0F, 0F);
+        Panel4 = new ModelRenderer(this, 0, 37);
+        Panel4.addBox(0F, 0F, 0F, 1, 13, 5);
+        Panel4.setRotationPoint(-4.5F, 11F, -2.5F);
+        Panel4.setTextureSize(32, 64);
+        Panel4.mirror = true;
+        setRotation(Panel4, 0F, 0F, 0F);
+        Top = new ModelRenderer(this, 13, 22);
+        Top.addBox(0F, 0F, 0F, 2, 2, 2);
+        Top.setRotationPoint(-1F, 8F, -1F);
+        Top.setTextureSize(32, 64);
+        Top.mirror = true;
+        setRotation(Top, 0F, 0F, 0F);
+        Exit = new ModelRenderer(this, 22, 22);
+        Exit.addBox(0F, 0F, 0F, 1, 1, 1);
+        Exit.setRotationPoint(1F, 8.2F, -0.5F);
+        Exit.setTextureSize(32, 64);
+        Exit.mirror = true;
+        setRotation(Exit, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Panel1.render(size);
+        Panel2.render(size);
+        Panel3.render(size);
+        Tank.render(size);
+        Panel4.render(size);
+        Top.render(size);
+        Exit.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyGasTank.png";
+    }
+
+    @Override
+    public String getTextureNameForTier(BaseTier tier) {
+        return this.getTextureName();
+    }
+}

src/main/java/mekanism/client/model/LegacyModelLogisticalSorter.java

@@ -0,0 +1,220 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.texture.TextureManager;
+
+public class LegacyModelLogisticalSorter
+    extends ModelMekanismBase implements IModelOnOff {
+    ModelRenderer LeftThing;
+    ModelRenderer RightThing;
+    ModelRenderer BottomPlate;
+    ModelRenderer TopPlate;
+    ModelRenderer LeftPlate;
+    ModelRenderer RightPlate;
+    ModelRenderer BR1Block1;
+    ModelRenderer BL1Block1;
+    ModelRenderer TL1Block1;
+    ModelRenderer TR1Block1;
+    ModelRenderer BR1Block2;
+    ModelRenderer BL1Block2;
+    ModelRenderer TL1Block2;
+    ModelRenderer TR1Block2;
+    ModelRenderer PoleBR;
+    ModelRenderer PoleTL;
+    ModelRenderer PoleTR;
+    ModelRenderer PoleBL;
+    ModelRenderer Base;
+    ModelRenderer PipeBase;
+    ModelRenderer DecorPlate;
+
+    public LegacyModelLogisticalSorter() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        LeftThing = new ModelRenderer(this, 0, 29);
+        LeftThing.addBox(0F, 0F, 0F, 1, 12, 1);
+        LeftThing.setRotationPoint(5.5F, 10F, 5F);
+        LeftThing.setTextureSize(128, 64);
+        LeftThing.mirror = true;
+        setRotation(LeftThing, 0F, 0F, 0F);
+        RightThing = new ModelRenderer(this, 0, 29);
+        RightThing.addBox(0F, 0F, 0F, 1, 12, 1);
+        RightThing.setRotationPoint(5.5F, 10F, -6F);
+        RightThing.setTextureSize(128, 64);
+        RightThing.mirror = true;
+        setRotation(RightThing, 0F, 0F, 0F);
+        BottomPlate = new ModelRenderer(this, 60, 7);
+        BottomPlate.addBox(0F, 0F, 0F, 12, 1, 4);
+        BottomPlate.setRotationPoint(-6F, 18F, -2F);
+        BottomPlate.setTextureSize(128, 64);
+        BottomPlate.mirror = true;
+        setRotation(BottomPlate, 0F, 0F, 0F);
+        TopPlate = new ModelRenderer(this, 60, 7);
+        TopPlate.addBox(0F, 0F, 0F, 12, 1, 4);
+        TopPlate.setRotationPoint(-6F, 13F, -2F);
+        TopPlate.setTextureSize(128, 64);
+        TopPlate.mirror = true;
+        setRotation(TopPlate, 0F, 0F, 0F);
+        LeftPlate = new ModelRenderer(this, 33, 5);
+        LeftPlate.addBox(0F, 0F, 0F, 12, 6, 1);
+        LeftPlate.setRotationPoint(-6F, 13F, 2F);
+        LeftPlate.setTextureSize(128, 64);
+        LeftPlate.mirror = true;
+        setRotation(LeftPlate, 0F, 0F, 0F);
+        RightPlate = new ModelRenderer(this, 33, 5);
+        RightPlate.addBox(0F, 0F, 0F, 12, 6, 1);
+        RightPlate.setRotationPoint(-6F, 13F, -3F);
+        RightPlate.setTextureSize(128, 64);
+        RightPlate.mirror = true;
+        setRotation(RightPlate, 0F, 0F, 0F);
+        BR1Block1 = new ModelRenderer(this, 33, 0);
+        BR1Block1.addBox(0F, 0F, 0F, 1, 2, 2);
+        BR1Block1.setRotationPoint(4F, 17.5F, -3.5F);
+        BR1Block1.setTextureSize(128, 64);
+        BR1Block1.mirror = true;
+        setRotation(BR1Block1, 0F, 0.0174533F, 0F);
+        BL1Block1 = new ModelRenderer(this, 33, 0);
+        BL1Block1.addBox(0F, 0F, 0F, 1, 2, 2);
+        BL1Block1.setRotationPoint(4F, 17.5F, 1.473333F);
+        BL1Block1.setTextureSize(128, 64);
+        BL1Block1.mirror = true;
+        setRotation(BL1Block1, 0F, 0F, 0F);
+        TL1Block1 = new ModelRenderer(this, 33, 0);
+        TL1Block1.addBox(0F, 0F, 0F, 1, 2, 2);
+        TL1Block1.setRotationPoint(4F, 12.5F, 1.473333F);
+        TL1Block1.setTextureSize(128, 64);
+        TL1Block1.mirror = true;
+        setRotation(TL1Block1, 0F, 0F, 0F);
+        TR1Block1 = new ModelRenderer(this, 33, 0);
+        TR1Block1.addBox(0F, 0F, 0F, 1, 2, 2);
+        TR1Block1.setRotationPoint(4F, 12.5F, -3.5F);
+        TR1Block1.setTextureSize(128, 64);
+        TR1Block1.mirror = true;
+        setRotation(TR1Block1, 0F, 0F, 0F);
+        BR1Block2 = new ModelRenderer(this, 33, 0);
+        BR1Block2.addBox(0F, 0F, 0F, 1, 2, 2);
+        BR1Block2.setRotationPoint(-5F, 17.5F, -3.5F);
+        BR1Block2.setTextureSize(128, 64);
+        BR1Block2.mirror = true;
+        setRotation(BR1Block2, 0F, 0F, 0F);
+        BL1Block2 = new ModelRenderer(this, 33, 0);
+        BL1Block2.addBox(0F, 0F, 0F, 1, 2, 2);
+        BL1Block2.setRotationPoint(-5F, 17.5F, 1.473333F);
+        BL1Block2.setTextureSize(128, 64);
+        BL1Block2.mirror = true;
+        setRotation(BL1Block2, 0F, 0F, 0F);
+        TL1Block2 = new ModelRenderer(this, 33, 0);
+        TL1Block2.addBox(0F, 0F, 0F, 1, 2, 2);
+        TL1Block2.setRotationPoint(-5F, 12.5F, 1.473333F);
+        TL1Block2.setTextureSize(128, 64);
+        TL1Block2.mirror = true;
+        setRotation(TL1Block2, 0F, 0F, 0F);
+        TR1Block2 = new ModelRenderer(this, 33, 0);
+        TR1Block2.addBox(0F, 0F, 0F, 1, 2, 2);
+        TR1Block2.setRotationPoint(-5F, 12.5F, -3.5F);
+        TR1Block2.setTextureSize(128, 64);
+        TR1Block2.mirror = true;
+        setRotation(TR1Block2, 0F, 0F, 0F);
+        PoleBR = new ModelRenderer(this, 40, 0);
+        PoleBR.addBox(0F, 0F, 0F, 8, 1, 1);
+        PoleBR.setRotationPoint(-4F, 18.2F, 2.2F);
+        PoleBR.setTextureSize(128, 64);
+        PoleBR.mirror = true;
+        setRotation(PoleBR, 0F, 0F, 0F);
+        PoleTL = new ModelRenderer(this, 40, 0);
+        PoleTL.addBox(0F, 0F, 0F, 8, 1, 1);
+        PoleTL.setRotationPoint(-4F, 12.8F, -3.2F);
+        PoleTL.setTextureSize(128, 64);
+        PoleTL.mirror = true;
+        setRotation(PoleTL, 0F, 0F, 0F);
+        PoleTR = new ModelRenderer(this, 40, 0);
+        PoleTR.addBox(0F, 0F, 0F, 8, 1, 1);
+        PoleTR.setRotationPoint(-4F, 12.8F, 2.2F);
+        PoleTR.setTextureSize(128, 64);
+        PoleTR.mirror = true;
+        setRotation(PoleTR, 0F, 0F, 0F);
+        PoleBL = new ModelRenderer(this, 40, 0);
+        PoleBL.addBox(0F, 0F, 0F, 8, 1, 1);
+        PoleBL.setRotationPoint(-4F, 18.2F, -3.2F);
+        PoleBL.setTextureSize(128, 64);
+        PoleBL.mirror = true;
+        setRotation(PoleBL, 0F, 0F, 0F);
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 2, 14, 14);
+        Base.setRotationPoint(6F, 9F, -7F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        PipeBase = new ModelRenderer(this, 33, 13);
+        PipeBase.addBox(0F, 0F, 0F, 3, 8, 8);
+        PipeBase.setRotationPoint(-8F, 12F, -4F);
+        PipeBase.setTextureSize(128, 64);
+        PipeBase.mirror = true;
+        setRotation(PipeBase, 0F, 0F, 0F);
+        DecorPlate = new ModelRenderer(this, 5, 29);
+        DecorPlate.addBox(0F, 0F, 0F, 1, 8, 8);
+        DecorPlate.setRotationPoint(5F, 12F, -4F);
+        DecorPlate.setTextureSize(128, 64);
+        DecorPlate.mirror = true;
+        setRotation(DecorPlate, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size, boolean active, TextureManager renderer) {
+        LeftThing.render(size);
+        RightThing.render(size);
+        BottomPlate.render(size);
+        TopPlate.render(size);
+        LeftPlate.render(size);
+        RightPlate.render(size);
+
+        if (active) {
+            MekanismRenderer.glowOn();
+        }
+
+        BR1Block1.render(size);
+        BL1Block1.render(size);
+        TL1Block1.render(size);
+        TR1Block1.render(size);
+        BR1Block2.render(size);
+        BL1Block2.render(size);
+        TL1Block2.render(size);
+        TR1Block2.render(size);
+
+        if (active) {
+            MekanismRenderer.glowOff();
+        }
+
+        PoleBR.render(size);
+        PoleTL.render(size);
+        PoleTR.render(size);
+        PoleBL.render(size);
+        Base.render(size);
+        PipeBase.render(size);
+        DecorPlate.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyLogisticalSorter.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return on ? "LegacyLogisticalSorterOn.png" : this.getTextureName();
+    }
+
+    @Override
+    public void render(float size) {
+        this.render(size, false, Minecraft.getMinecraft().renderEngine);
+    }
+}

src/main/java/mekanism/client/model/LegacyModelMetallurgicInfuser.java

@@ -0,0 +1,228 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelMetallurgicInfuser extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer RightChamber;
+    ModelRenderer TopChamber;
+    ModelRenderer BackChamber;
+    ModelRenderer LeftChamber;
+    ModelRenderer FCTop;
+    ModelRenderer FCBottom;
+    ModelRenderer FCRight;
+    ModelRenderer FCLeft;
+    ModelRenderer FCDoor;
+    ModelRenderer Cable1;
+    ModelRenderer Cable3;
+    ModelRenderer Cable5;
+    ModelRenderer Cable2;
+    ModelRenderer Cable4;
+    ModelRenderer Cable6;
+    ModelRenderer TopPanelDec;
+    ModelRenderer BackPlate;
+    ModelRenderer TopPanel;
+    ModelRenderer TopPanelExtr;
+    ModelRenderer ConnectorRight;
+    ModelRenderer ConnectorLeft;
+    ModelRenderer ConnectorWireRight;
+    ModelRenderer ConnectorWireLeft;
+    ModelRenderer ConnectorWireTop;
+
+    public LegacyModelMetallurgicInfuser() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 14, 2, 16);
+        Base.setRotationPoint(-7F, 22F, -8F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        RightChamber = new ModelRenderer(this, 61, 0);
+        RightChamber.addBox(0F, 0F, 0F, 1, 6, 5);
+        RightChamber.setRotationPoint(5.5F, 16F, -6F);
+        RightChamber.setTextureSize(128, 64);
+        RightChamber.mirror = true;
+        setRotation(RightChamber, 0F, 0F, 0F);
+        TopChamber = new ModelRenderer(this, 86, 12);
+        TopChamber.addBox(0F, 0F, 0F, 11, 1, 5);
+        TopChamber.setRotationPoint(-5.5F, 15F, -6F);
+        TopChamber.setTextureSize(128, 64);
+        TopChamber.mirror = true;
+        setRotation(TopChamber, 0F, 0F, 0F);
+        BackChamber = new ModelRenderer(this, 74, 0);
+        BackChamber.addBox(0F, 0F, 0F, 11, 6, 1);
+        BackChamber.setRotationPoint(-5.5F, 16F, -1F);
+        BackChamber.setTextureSize(128, 64);
+        BackChamber.mirror = true;
+        setRotation(BackChamber, 0F, 0F, 0F);
+        LeftChamber = new ModelRenderer(this, 61, 0);
+        LeftChamber.addBox(0F, 0F, 0F, 1, 6, 5);
+        LeftChamber.setRotationPoint(-6.5F, 16F, -6F);
+        LeftChamber.setTextureSize(128, 64);
+        LeftChamber.mirror = true;
+        setRotation(LeftChamber, 0F, 0F, 0F);
+        FCTop = new ModelRenderer(this, 99, 6);
+        FCTop.addBox(0F, 0F, 0F, 11, 1, 1);
+        FCTop.setRotationPoint(-5.5F, 16F, -7F);
+        FCTop.setTextureSize(128, 64);
+        FCTop.mirror = true;
+        setRotation(FCTop, 0F, 0F, 0F);
+        FCBottom = new ModelRenderer(this, 99, 6);
+        FCBottom.addBox(0F, 0F, 0F, 11, 1, 1);
+        FCBottom.setRotationPoint(-5.5F, 21F, -7F);
+        FCBottom.setTextureSize(128, 64);
+        FCBottom.mirror = true;
+        setRotation(FCBottom, 0F, 0F, 0F);
+        FCRight = new ModelRenderer(this, 61, 11);
+        FCRight.addBox(0F, 0F, 0F, 1, 4, 1);
+        FCRight.setRotationPoint(4.5F, 17F, -7F);
+        FCRight.setTextureSize(128, 64);
+        FCRight.mirror = true;
+        setRotation(FCRight, 0F, 0F, 0F);
+        FCLeft = new ModelRenderer(this, 61, 11);
+        FCLeft.addBox(0F, 0F, 0F, 1, 4, 1);
+        FCLeft.setRotationPoint(-5.5F, 17F, -7F);
+        FCLeft.setTextureSize(128, 64);
+        FCLeft.mirror = true;
+        setRotation(FCLeft, 0F, 0F, 0F);
+        FCDoor = new ModelRenderer(this, 99, 0);
+        FCDoor.addBox(0F, -2F, -0.5F, 9, 4, 1);
+        FCDoor.setRotationPoint(-4.5F, 19F, -7F);
+        FCDoor.setTextureSize(128, 64);
+        FCDoor.mirror = true;
+        setRotation(FCDoor, 0F, 0F, 0F);
+        Cable1 = new ModelRenderer(this, 105, 19);
+        Cable1.addBox(0F, 0F, 0F, 1, 1, 7);
+        Cable1.setRotationPoint(-4.5F, 19.5F, 0F);
+        Cable1.setTextureSize(128, 64);
+        Cable1.mirror = true;
+        setRotation(Cable1, 0F, 0.0174533F, 0F);
+        Cable3 = new ModelRenderer(this, 86, 19);
+        Cable3.addBox(0F, 0F, 0F, 2, 2, 7);
+        Cable3.setRotationPoint(3F, 18F, 0F);
+        Cable3.setTextureSize(128, 64);
+        Cable3.mirror = true;
+        setRotation(Cable3, 0F, 0.0174533F, 0F);
+        Cable5 = new ModelRenderer(this, 105, 19);
+        Cable5.addBox(0F, 0F, 0F, 1, 1, 7);
+        Cable5.setRotationPoint(3.5F, 19.5F, 0F);
+        Cable5.setTextureSize(128, 64);
+        Cable5.mirror = true;
+        setRotation(Cable5, 0F, 0.0174533F, 0F);
+        Cable2 = new ModelRenderer(this, 86, 19);
+        Cable2.addBox(0F, 0F, 0F, 2, 2, 7);
+        Cable2.setRotationPoint(-5F, 18F, 0F);
+        Cable2.setTextureSize(128, 64);
+        Cable2.mirror = true;
+        setRotation(Cable2, 0F, 0F, 0F);
+        Cable4 = new ModelRenderer(this, 105, 19);
+        Cable4.addBox(0F, 0F, 0F, 1, 1, 7);
+        Cable4.setRotationPoint(-4.5F, 17.5F, 0F);
+        Cable4.setTextureSize(128, 64);
+        Cable4.mirror = true;
+        setRotation(Cable4, 0F, 0.0174533F, 0F);
+        Cable6 = new ModelRenderer(this, 105, 19);
+        Cable6.addBox(0F, 0F, 0F, 1, 1, 7);
+        Cable6.setRotationPoint(3.5F, 17.5F, 0F);
+        Cable6.setTextureSize(128, 64);
+        Cable6.mirror = true;
+        setRotation(Cable6, 0F, 0.0174533F, 0F);
+        TopPanelDec = new ModelRenderer(this, 33, 28);
+        TopPanelDec.addBox(0F, 0F, 0F, 13, 1, 1);
+        TopPanelDec.setRotationPoint(-6.5F, 11.5F, 5.5F);
+        TopPanelDec.setTextureSize(128, 64);
+        TopPanelDec.mirror = true;
+        setRotation(TopPanelDec, 0F, 0F, 0F);
+        BackPlate = new ModelRenderer(this, 0, 19);
+        BackPlate.addBox(0F, 0F, 0F, 14, 12, 2);
+        BackPlate.setRotationPoint(-7F, 10F, 6F);
+        BackPlate.setTextureSize(128, 64);
+        BackPlate.mirror = true;
+        setRotation(BackPlate, 0F, 0F, 0F);
+        TopPanel = new ModelRenderer(this, 33, 19);
+        TopPanel.addBox(0F, 0F, 0F, 14, 2, 3);
+        TopPanel.setRotationPoint(-7F, 10F, 3F);
+        TopPanel.setTextureSize(128, 64);
+        TopPanel.mirror = true;
+        setRotation(TopPanel, 0F, 0F, 0F);
+        TopPanelExtr = new ModelRenderer(this, 33, 25);
+        TopPanelExtr.addBox(0F, 0F, 0F, 14, 1, 1);
+        TopPanelExtr.setRotationPoint(-7F, 10F, 2F);
+        TopPanelExtr.setTextureSize(128, 64);
+        TopPanelExtr.mirror = true;
+        setRotation(TopPanelExtr, 0F, 0F, 0F);
+        ConnectorRight = new ModelRenderer(this, 68, 19);
+        ConnectorRight.addBox(0F, 0F, 0F, 3, 1, 3);
+        ConnectorRight.setRotationPoint(1.5F, 14F, -5F);
+        ConnectorRight.setTextureSize(128, 64);
+        ConnectorRight.mirror = true;
+        setRotation(ConnectorRight, 0F, 0F, 0F);
+        ConnectorLeft = new ModelRenderer(this, 68, 19);
+        ConnectorLeft.addBox(0F, 0F, 0F, 3, 1, 3);
+        ConnectorLeft.setRotationPoint(-4.5F, 14F, -5F);
+        ConnectorLeft.setTextureSize(128, 64);
+        ConnectorLeft.mirror = true;
+        setRotation(ConnectorLeft, 0F, 0F, 0F);
+        ConnectorWireRight = new ModelRenderer(this, 68, 24);
+        ConnectorWireRight.addBox(0F, 0F, 0F, 1, 3, 1);
+        ConnectorWireRight.setRotationPoint(2.5F, 11F, -4F);
+        ConnectorWireRight.setTextureSize(128, 64);
+        ConnectorWireRight.mirror = true;
+        setRotation(ConnectorWireRight, 0F, 0F, 0F);
+        ConnectorWireLeft = new ModelRenderer(this, 68, 24);
+        ConnectorWireLeft.addBox(0F, 0F, 0F, 1, 3, 1);
+        ConnectorWireLeft.setRotationPoint(-3.5F, 11F, -4F);
+        ConnectorWireLeft.setTextureSize(128, 64);
+        ConnectorWireLeft.mirror = true;
+        setRotation(ConnectorWireLeft, 0F, 0F, 0F);
+        ConnectorWireTop = new ModelRenderer(this, 68, 29);
+        ConnectorWireTop.addBox(0F, 0F, 0F, 5, 1, 1);
+        ConnectorWireTop.setRotationPoint(-2.5F, 11F, -4F);
+        ConnectorWireTop.setTextureSize(128, 64);
+        ConnectorWireTop.mirror = true;
+        setRotation(ConnectorWireTop, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        RightChamber.render(size);
+        TopChamber.render(size);
+        BackChamber.render(size);
+        LeftChamber.render(size);
+        FCTop.render(size);
+        FCBottom.render(size);
+        FCRight.render(size);
+        FCLeft.render(size);
+        FCDoor.render(size);
+        Cable1.render(size);
+        Cable3.render(size);
+        Cable5.render(size);
+        Cable2.render(size);
+        Cable4.render(size);
+        Cable6.render(size);
+        TopPanelDec.render(size);
+        BackPlate.render(size);
+        TopPanel.render(size);
+        TopPanelExtr.render(size);
+        ConnectorRight.render(size);
+        ConnectorLeft.render(size);
+        ConnectorWireRight.render(size);
+        ConnectorWireLeft.render(size);
+        ConnectorWireTop.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyMetallurgicInfuser.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelPressurizedReactionChamber.java

@@ -0,0 +1,180 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelPressurizedReactionChamber extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer GasRight;
+    ModelRenderer GasLeft;
+    ModelRenderer GasConnector;
+    ModelRenderer FluidBack;
+    ModelRenderer CoreBase;
+    ModelRenderer Core;
+    ModelRenderer PoleRF;
+    ModelRenderer PoleFL;
+    ModelRenderer PoleLB;
+    ModelRenderer PoleBR;
+    ModelRenderer PoleR;
+    ModelRenderer PoleL;
+    ModelRenderer FrontPanel;
+    ModelRenderer TubeThing;
+    ModelRenderer CenterCore;
+    ModelRenderer BackConnector;
+    ModelRenderer BackCore;
+    ModelRenderer TopPanel;
+
+    public LegacyModelPressurizedReactionChamber() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 16, 1, 16);
+        Base.setRotationPoint(-8F, 23F, -8F);
+        Base.setTextureSize(128, 128);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        GasRight = new ModelRenderer(this, 64, 12);
+        GasRight.addBox(0F, 0F, 0F, 1, 6, 6);
+        GasRight.setRotationPoint(-8F, 13F, -3F);
+        GasRight.setTextureSize(128, 128);
+        GasRight.mirror = true;
+        setRotation(GasRight, 0F, 0F, 0F);
+        GasLeft = new ModelRenderer(this, 64, 12);
+        GasLeft.addBox(0F, 0F, 0F, 1, 6, 6);
+        GasLeft.setRotationPoint(7F, 13F, -3F);
+        GasLeft.setTextureSize(128, 128);
+        GasLeft.mirror = true;
+        setRotation(GasLeft, 0F, 0F, 0F);
+        GasConnector = new ModelRenderer(this, 22, 38);
+        GasConnector.addBox(0F, 0F, 0F, 14, 2, 2);
+        GasConnector.setRotationPoint(-7F, 15F, -1F);
+        GasConnector.setTextureSize(128, 128);
+        GasConnector.mirror = true;
+        setRotation(GasConnector, 0F, 0F, 0F);
+        FluidBack = new ModelRenderer(this, 50, 24);
+        FluidBack.addBox(0F, 0F, 0F, 8, 8, 1);
+        FluidBack.setRotationPoint(-4F, 12F, 7F);
+        FluidBack.setTextureSize(128, 128);
+        FluidBack.mirror = true;
+        setRotation(FluidBack, 0F, 0F, 0F);
+        CoreBase = new ModelRenderer(this, 64, 0);
+        CoreBase.addBox(0F, 0F, 0F, 10, 1, 11);
+        CoreBase.setRotationPoint(-5F, 22F, -6F);
+        CoreBase.setTextureSize(128, 128);
+        CoreBase.mirror = true;
+        setRotation(CoreBase, 0F, 0F, 0F);
+        Core = new ModelRenderer(this, 0, 17);
+        Core.addBox(0F, 0F, 0F, 12, 8, 13);
+        Core.setRotationPoint(-6F, 14F, -7F);
+        Core.setTextureSize(128, 128);
+        Core.mirror = true;
+        setRotation(Core, 0F, 0F, 0F);
+        PoleRF = new ModelRenderer(this, 38, 42);
+        PoleRF.addBox(0F, 0F, 0F, 1, 6, 1);
+        PoleRF.setRotationPoint(-6F, 8F, -7F);
+        PoleRF.setTextureSize(128, 128);
+        PoleRF.mirror = true;
+        setRotation(PoleRF, 0F, 0F, 0F);
+        PoleFL = new ModelRenderer(this, 38, 42);
+        PoleFL.addBox(0F, 0F, 0F, 1, 6, 1);
+        PoleFL.setRotationPoint(5F, 8F, -7F);
+        PoleFL.setTextureSize(128, 128);
+        PoleFL.mirror = true;
+        setRotation(PoleFL, 0F, 0F, 0F);
+        PoleLB = new ModelRenderer(this, 38, 42);
+        PoleLB.addBox(0F, 0F, 0F, 1, 6, 1);
+        PoleLB.setRotationPoint(5F, 8F, 5F);
+        PoleLB.setTextureSize(128, 128);
+        PoleLB.mirror = true;
+        setRotation(PoleLB, 0F, 0F, 0F);
+        PoleBR = new ModelRenderer(this, 38, 42);
+        PoleBR.addBox(0F, -2F, 0F, 1, 6, 1);
+        PoleBR.setRotationPoint(-6F, 10F, 5F);
+        PoleBR.setTextureSize(128, 128);
+        PoleBR.mirror = true;
+        setRotation(PoleBR, 0F, 0F, 0F);
+        PoleR = new ModelRenderer(this, 0, 57);
+        PoleR.addBox(0F, 0F, 0F, 1, 1, 11);
+        PoleR.setRotationPoint(-6F, 8F, -6F);
+        PoleR.setTextureSize(128, 128);
+        PoleR.mirror = true;
+        setRotation(PoleR, 0F, 0F, 0F);
+        PoleL = new ModelRenderer(this, 0, 57);
+        PoleL.addBox(0F, 0F, 0F, 1, 1, 11);
+        PoleL.setRotationPoint(5F, 8F, -6F);
+        PoleL.setTextureSize(128, 128);
+        PoleL.mirror = true;
+        setRotation(PoleL, 0F, 0F, 0F);
+        FrontPanel = new ModelRenderer(this, 0, 38);
+        FrontPanel.addBox(0F, 0F, 0F, 10, 12, 1);
+        FrontPanel.setRotationPoint(-5F, 9F, -8F);
+        FrontPanel.setTextureSize(128, 128);
+        FrontPanel.mirror = true;
+        setRotation(FrontPanel, 0F, 0F, 0F);
+        TubeThing = new ModelRenderer(this, 22, 42);
+        TubeThing.addBox(0F, 0F, 0F, 2, 2, 6);
+        TubeThing.setRotationPoint(-1F, 12F, -7F);
+        TubeThing.setTextureSize(128, 128);
+        TubeThing.mirror = true;
+        setRotation(TubeThing, 0F, 0F, 0F);
+        CenterCore = new ModelRenderer(this, 84, 12);
+        CenterCore.addBox(0F, 0F, 0F, 4, 1, 4);
+        CenterCore.setRotationPoint(-2F, 13F, -3F);
+        CenterCore.setTextureSize(128, 128);
+        CenterCore.mirror = true;
+        setRotation(CenterCore, 0F, 0F, 0F);
+        BackConnector = new ModelRenderer(this, 78, 12);
+        BackConnector.addBox(0F, 0F, 0F, 2, 5, 1);
+        BackConnector.setRotationPoint(-1F, 13F, 6F);
+        BackConnector.setTextureSize(128, 128);
+        BackConnector.mirror = true;
+        setRotation(BackConnector, 0F, 0F, 0F);
+        BackCore = new ModelRenderer(this, 0, 51);
+        BackCore.addBox(0F, 0F, 0F, 2, 1, 5);
+        BackCore.setRotationPoint(-1F, 13F, 1F);
+        BackCore.setTextureSize(128, 128);
+        BackCore.mirror = true;
+        setRotation(BackCore, 0F, 0F, 0F);
+        TopPanel = new ModelRenderer(this, 0, 69);
+        TopPanel.addBox(0F, 0F, 0F, 10, 1, 13);
+        TopPanel.setRotationPoint(-5F, 8F, -7F);
+        TopPanel.setTextureSize(128, 128);
+        TopPanel.mirror = true;
+        setRotation(TopPanel, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        GasRight.render(size);
+        GasLeft.render(size);
+        GasConnector.render(size);
+        FluidBack.render(size);
+        CoreBase.render(size);
+        Core.render(size);
+        PoleRF.render(size);
+        PoleFL.render(size);
+        PoleLB.render(size);
+        PoleBR.render(size);
+        PoleR.render(size);
+        PoleL.render(size);
+        FrontPanel.render(size);
+        TubeThing.render(size);
+        CenterCore.render(size);
+        BackConnector.render(size);
+        BackCore.render(size);
+        TopPanel.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyPressurizedReactionChamber.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelRotaryCondensentrator.java

@@ -0,0 +1,229 @@
+
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelRotaryCondensentrator extends ModelMekanismBase {
+    ModelRenderer GasBottleLid1;
+    ModelRenderer GasBottleLid2;
+    ModelRenderer GasBottleDecor1;
+    ModelRenderer GasBottleDecor2;
+    ModelRenderer GasBottleDecor3;
+    ModelRenderer GasBottleDecor4;
+    ModelRenderer GasBottle1;
+    ModelRenderer GasBottle2;
+    ModelRenderer GasBottleBot1;
+    ModelRenderer GasBottleBot2;
+    ModelRenderer LiqBottleLid1;
+    ModelRenderer LiqBottleLid2;
+    ModelRenderer LiqBottleBot1;
+    ModelRenderer LiqBottleBot2;
+    ModelRenderer LiqBottle2;
+    ModelRenderer LiqBottle1;
+    ModelRenderer LiqBottleDecor1;
+    ModelRenderer LiqBottleDecor2;
+    ModelRenderer LiqBottleDecor3;
+    ModelRenderer LiqBottleDecor4;
+    ModelRenderer GasInput;
+    ModelRenderer MidSection1;
+    ModelRenderer MidSection2;
+    ModelRenderer LiquidOutput;
+    ModelRenderer MidSection3;
+
+    public LegacyModelRotaryCondensentrator() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        GasBottleLid1 = new ModelRenderer(this, 0, 40);
+        GasBottleLid1.addBox(0F, 0F, 0F, 6, 1, 6);
+        GasBottleLid1.setRotationPoint(-7F, 11F, 1F);
+        GasBottleLid1.setTextureSize(128, 128);
+        GasBottleLid1.mirror = true;
+        setRotation(GasBottleLid1, 0F, 0F, 0F);
+        GasBottleLid2 = new ModelRenderer(this, 0, 40);
+        GasBottleLid2.addBox(0F, 0F, 0F, 6, 1, 6);
+        GasBottleLid2.setRotationPoint(1F, 11F, 1F);
+        GasBottleLid2.setTextureSize(128, 128);
+        GasBottleLid2.mirror = true;
+        setRotation(GasBottleLid2, 0F, 0F, 0F);
+        GasBottleDecor1 = new ModelRenderer(this, 0, 33);
+        GasBottleDecor1.addBox(0F, 0F, 0F, 5, 1, 5);
+        GasBottleDecor1.setRotationPoint(1.5F, 21F, 1.5F);
+        GasBottleDecor1.setTextureSize(128, 128);
+        GasBottleDecor1.mirror = true;
+        setRotation(GasBottleDecor1, 0F, 0F, 0F);
+        GasBottleDecor2 = new ModelRenderer(this, 0, 33);
+        GasBottleDecor2.addBox(0F, 0F, 0F, 5, 1, 5);
+        GasBottleDecor2.setRotationPoint(1.5F, 13F, 1.5F);
+        GasBottleDecor2.setTextureSize(128, 128);
+        GasBottleDecor2.mirror = true;
+        setRotation(GasBottleDecor2, 0F, 0F, 0F);
+        GasBottleDecor3 = new ModelRenderer(this, 0, 33);
+        GasBottleDecor3.addBox(0F, 0F, 0F, 5, 1, 5);
+        GasBottleDecor3.setRotationPoint(-6.5F, 21F, 1.5F);
+        GasBottleDecor3.setTextureSize(128, 128);
+        GasBottleDecor3.mirror = true;
+        setRotation(GasBottleDecor3, 0F, 0F, 0F);
+        GasBottleDecor4 = new ModelRenderer(this, 0, 33);
+        GasBottleDecor4.addBox(0F, 0F, 0F, 5, 1, 5);
+        GasBottleDecor4.setRotationPoint(-6.5F, 13F, 1.5F);
+        GasBottleDecor4.setTextureSize(128, 128);
+        GasBottleDecor4.mirror = true;
+        setRotation(GasBottleDecor4, 0F, 0F, 0F);
+        GasBottle1 = new ModelRenderer(this, 0, 48);
+        GasBottle1.addBox(0F, 0F, 0F, 4, 11, 4);
+        GasBottle1.setRotationPoint(-6F, 12F, 2F);
+        GasBottle1.setTextureSize(128, 128);
+        GasBottle1.mirror = true;
+        setRotation(GasBottle1, 0F, 0F, 0F);
+        GasBottle2 = new ModelRenderer(this, 0, 48);
+        GasBottle2.addBox(0F, 0F, 0F, 4, 11, 4);
+        GasBottle2.setRotationPoint(2F, 12F, 2F);
+        GasBottle2.setTextureSize(128, 128);
+        GasBottle2.mirror = true;
+        setRotation(GasBottle2, 0F, 0F, 0F);
+        GasBottleBot1 = new ModelRenderer(this, 0, 40);
+        GasBottleBot1.addBox(0F, 0F, 0F, 6, 1, 6);
+        GasBottleBot1.setRotationPoint(-7F, 23F, 1F);
+        GasBottleBot1.setTextureSize(128, 128);
+        GasBottleBot1.mirror = true;
+        setRotation(GasBottleBot1, 0F, 0F, 0F);
+        GasBottleBot2 = new ModelRenderer(this, 0, 40);
+        GasBottleBot2.addBox(0F, 0F, 0F, 6, 1, 6);
+        GasBottleBot2.setRotationPoint(1F, 23F, 1F);
+        GasBottleBot2.setTextureSize(128, 128);
+        GasBottleBot2.mirror = true;
+        setRotation(GasBottleBot2, 0F, 0F, 0F);
+        LiqBottleLid1 = new ModelRenderer(this, 25, 40);
+        LiqBottleLid1.addBox(0F, 0F, 0F, 6, 1, 6);
+        LiqBottleLid1.setRotationPoint(-7F, 11F, -7F);
+        LiqBottleLid1.setTextureSize(128, 128);
+        LiqBottleLid1.mirror = true;
+        setRotation(LiqBottleLid1, 0F, 0F, 0F);
+        LiqBottleLid2 = new ModelRenderer(this, 25, 40);
+        LiqBottleLid2.addBox(0F, 0F, 0F, 6, 1, 6);
+        LiqBottleLid2.setRotationPoint(1F, 11F, -7F);
+        LiqBottleLid2.setTextureSize(128, 128);
+        LiqBottleLid2.mirror = true;
+        setRotation(LiqBottleLid2, 0F, 0F, 0F);
+        LiqBottleBot1 = new ModelRenderer(this, 25, 40);
+        LiqBottleBot1.addBox(0F, 0F, 0F, 6, 1, 6);
+        LiqBottleBot1.setRotationPoint(-7F, 23F, -7F);
+        LiqBottleBot1.setTextureSize(128, 128);
+        LiqBottleBot1.mirror = true;
+        setRotation(LiqBottleBot1, 0F, 0F, 0F);
+        LiqBottleBot2 = new ModelRenderer(this, 25, 40);
+        LiqBottleBot2.addBox(0F, 0F, 0F, 6, 1, 6);
+        LiqBottleBot2.setRotationPoint(1F, 23F, -7F);
+        LiqBottleBot2.setTextureSize(128, 128);
+        LiqBottleBot2.mirror = true;
+        setRotation(LiqBottleBot2, 0F, 0F, 0F);
+        LiqBottle2 = new ModelRenderer(this, 25, 48);
+        LiqBottle2.addBox(0F, 0F, 0F, 4, 11, 4);
+        LiqBottle2.setRotationPoint(2F, 12F, -6F);
+        LiqBottle2.setTextureSize(128, 128);
+        LiqBottle2.mirror = true;
+        setRotation(LiqBottle2, 0F, 0F, 0F);
+        LiqBottle1 = new ModelRenderer(this, 25, 48);
+        LiqBottle1.addBox(0F, 0F, 0F, 4, 11, 4);
+        LiqBottle1.setRotationPoint(-6F, 12F, -6F);
+        LiqBottle1.setTextureSize(128, 128);
+        LiqBottle1.mirror = true;
+        setRotation(LiqBottle1, 0F, 0F, 0F);
+        LiqBottleDecor1 = new ModelRenderer(this, 25, 33);
+        LiqBottleDecor1.addBox(0F, 0F, 0F, 5, 1, 5);
+        LiqBottleDecor1.setRotationPoint(1.5F, 21F, -6.5F);
+        LiqBottleDecor1.setTextureSize(128, 128);
+        LiqBottleDecor1.mirror = true;
+        setRotation(LiqBottleDecor1, 0F, 0F, 0F);
+        LiqBottleDecor2 = new ModelRenderer(this, 25, 33);
+        LiqBottleDecor2.addBox(0F, 0F, 0F, 5, 1, 5);
+        LiqBottleDecor2.setRotationPoint(1.5F, 13F, -6.5F);
+        LiqBottleDecor2.setTextureSize(128, 128);
+        LiqBottleDecor2.mirror = true;
+        setRotation(LiqBottleDecor2, 0F, 0F, 0F);
+        LiqBottleDecor3 = new ModelRenderer(this, 25, 33);
+        LiqBottleDecor3.addBox(0F, 0F, 0F, 5, 1, 5);
+        LiqBottleDecor3.setRotationPoint(-6.5F, 21F, -6.5F);
+        LiqBottleDecor3.setTextureSize(128, 128);
+        LiqBottleDecor3.mirror = true;
+        setRotation(LiqBottleDecor3, 0F, 0F, 0F);
+        LiqBottleDecor4 = new ModelRenderer(this, 25, 33);
+        LiqBottleDecor4.addBox(0F, 0F, 0F, 5, 1, 5);
+        LiqBottleDecor4.setRotationPoint(-6.5F, 13F, -6.5F);
+        LiqBottleDecor4.setTextureSize(128, 128);
+        LiqBottleDecor4.mirror = true;
+        setRotation(LiqBottleDecor4, 0F, 0F, 0F);
+        GasInput = new ModelRenderer(this, 0, 24);
+        GasInput.addBox(0F, 0F, 0F, 6, 6, 1);
+        GasInput.setRotationPoint(-3F, 13F, 7F);
+        GasInput.setTextureSize(128, 128);
+        GasInput.mirror = true;
+        setRotation(GasInput, 0F, 0F, 0F);
+        MidSection1 = new ModelRenderer(this, 15, 20);
+        MidSection1.addBox(0F, 0F, 0F, 4, 5, 6);
+        MidSection1.setRotationPoint(-2F, 18F, 1F);
+        MidSection1.setTextureSize(128, 128);
+        MidSection1.mirror = true;
+        setRotation(MidSection1, 0F, 0F, 0F);
+        MidSection2 = new ModelRenderer(this, 37, 0);
+        MidSection2.addBox(0F, 0F, 0F, 6, 7, 8);
+        MidSection2.setRotationPoint(-3F, 17F, -7F);
+        MidSection2.setTextureSize(128, 128);
+        MidSection2.mirror = true;
+        setRotation(MidSection2, 0F, 0F, 0F);
+        LiquidOutput = new ModelRenderer(this, 36, 22);
+        LiquidOutput.addBox(0F, 0F, 0F, 8, 8, 1);
+        LiquidOutput.setRotationPoint(-4F, 12F, -8F);
+        LiquidOutput.setTextureSize(128, 128);
+        LiquidOutput.mirror = true;
+        setRotation(LiquidOutput, 0F, 0F, 0F);
+        MidSection3 = new ModelRenderer(this, 0, 0);
+        MidSection3.addBox(0F, 0F, 0F, 4, 2, 14);
+        MidSection3.setRotationPoint(-2F, 15F, -7F);
+        MidSection3.setTextureSize(128, 128);
+        MidSection3.mirror = true;
+        setRotation(MidSection3, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        GasBottleLid1.render(size);
+        GasBottleLid2.render(size);
+        GasBottleDecor1.render(size);
+        GasBottleDecor2.render(size);
+        GasBottleDecor3.render(size);
+        GasBottleDecor4.render(size);
+        GasBottle1.render(size);
+        GasBottle2.render(size);
+        GasBottleBot1.render(size);
+        GasBottleBot2.render(size);
+        LiqBottleLid1.render(size);
+        LiqBottleLid2.render(size);
+        LiqBottleBot1.render(size);
+        LiqBottleBot2.render(size);
+        LiqBottle2.render(size);
+        LiqBottle1.render(size);
+        LiqBottleDecor1.render(size);
+        LiqBottleDecor2.render(size);
+        LiqBottleDecor3.render(size);
+        LiqBottleDecor4.render(size);
+        GasInput.render(size);
+        MidSection1.render(size);
+        MidSection2.render(size);
+        LiquidOutput.render(size);
+        MidSection3.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyRotaryCondensentrator.png";
+    }
+}

src/main/java/mekanism/client/model/LegacyModelSeismicVibrator.java

@@ -0,0 +1,155 @@
+package mekanism.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+import org.lwjgl.opengl.GL11;
+
+public class LegacyModelSeismicVibrator
+    extends ModelMekanismBase implements IModelSeismicVibrator {
+    ModelRenderer Base;
+    ModelRenderer Tower;
+    ModelRenderer TowerTop;
+    ModelRenderer TopPanel;
+    ModelRenderer Vibrator;
+    ModelRenderer PoleBR;
+    ModelRenderer PoleLB;
+    ModelRenderer PoleFL;
+    ModelRenderer PoleRF;
+    ModelRenderer PoleL;
+    ModelRenderer PoleR;
+    ModelRenderer Cable;
+    ModelRenderer ScreenFront;
+    ModelRenderer Keyboard;
+
+    public LegacyModelSeismicVibrator() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 16, 1, 16);
+        Base.setRotationPoint(-8F, 23F, -8F);
+        Base.setTextureSize(128, 128);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Tower = new ModelRenderer(this, 64, 0);
+        Tower.addBox(0F, 0F, 0F, 4, 11, 4);
+        Tower.setRotationPoint(-2F, 12F, -2F);
+        Tower.setTextureSize(128, 128);
+        Tower.mirror = true;
+        setRotation(Tower, 0F, 0F, 0F);
+        TowerTop = new ModelRenderer(this, 80, 0);
+        TowerTop.addBox(0F, 0F, 0F, 2, 1, 2);
+        TowerTop.setRotationPoint(-1F, 10F, -1F);
+        TowerTop.setTextureSize(128, 128);
+        TowerTop.mirror = true;
+        setRotation(TowerTop, 0F, 0F, 0F);
+        TopPanel = new ModelRenderer(this, 0, 17);
+        TopPanel.addBox(0F, 0F, 0F, 8, 1, 8);
+        TopPanel.setRotationPoint(-4F, 11F, -4F);
+        TopPanel.setTextureSize(128, 128);
+        TopPanel.mirror = true;
+        setRotation(TopPanel, 0F, 0F, 0F);
+        Vibrator = new ModelRenderer(this, 32, 17);
+        Vibrator.addBox(0F, 0F, 0F, 8, 4, 8);
+        Vibrator.setRotationPoint(-4F, 19F, -4F);
+        Vibrator.setTextureSize(128, 128);
+        Vibrator.mirror = true;
+        setRotation(Vibrator, 0F, 0F, 0F);
+        PoleBR = new ModelRenderer(this, 0, 26);
+        PoleBR.addBox(0F, 0F, 0F, 1, 13, 1);
+        PoleBR.setRotationPoint(-5F, 10F, 4F);
+        PoleBR.setTextureSize(128, 128);
+        PoleBR.mirror = true;
+        setRotation(PoleBR, 0F, 0F, 0F);
+        PoleLB = new ModelRenderer(this, 0, 26);
+        PoleLB.addBox(0F, 0F, 0F, 1, 13, 1);
+        PoleLB.setRotationPoint(4F, 10F, 4F);
+        PoleLB.setTextureSize(128, 128);
+        PoleLB.mirror = true;
+        setRotation(PoleLB, 0F, 0F, 0F);
+        PoleFL = new ModelRenderer(this, 0, 26);
+        PoleFL.addBox(0F, 0F, 0F, 1, 13, 1);
+        PoleFL.setRotationPoint(4F, 10F, -5F);
+        PoleFL.setTextureSize(128, 128);
+        PoleFL.mirror = true;
+        setRotation(PoleFL, 0F, 0F, 0F);
+        PoleRF = new ModelRenderer(this, 0, 26);
+        PoleRF.addBox(0F, 0F, 0F, 1, 13, 1);
+        PoleRF.setRotationPoint(-5F, 10F, -5F);
+        PoleRF.setTextureSize(128, 128);
+        PoleRF.mirror = true;
+        setRotation(PoleRF, 0F, 0F, 0F);
+        PoleL = new ModelRenderer(this, 4, 26);
+        PoleL.addBox(0F, 0F, 0F, 1, 1, 8);
+        PoleL.setRotationPoint(4F, 10F, -4F);
+        PoleL.setTextureSize(128, 128);
+        PoleL.mirror = true;
+        setRotation(PoleL, 0F, 0F, 0F);
+        PoleR = new ModelRenderer(this, 4, 26);
+        PoleR.addBox(0F, 0F, 0F, 1, 1, 8);
+        PoleR.setRotationPoint(-5F, 10F, -4F);
+        PoleR.setTextureSize(128, 128);
+        PoleR.mirror = true;
+        setRotation(PoleR, 0F, 0F, 0F);
+        Cable = new ModelRenderer(this, 64, 15);
+        Cable.addBox(0F, 0F, 0F, 6, 2, 6);
+        Cable.setRotationPoint(-3F, 8F, -3F);
+        Cable.setTextureSize(128, 128);
+        Cable.mirror = true;
+        setRotation(Cable, 0F, 0F, 0F);
+        ScreenFront = new ModelRenderer(this, 0, 40);
+        ScreenFront.addBox(0F, 0F, 0F, 8, 6, 1);
+        ScreenFront.setRotationPoint(-4F, 11F, -6F);
+        ScreenFront.setTextureSize(128, 128);
+        ScreenFront.mirror = true;
+        setRotation(ScreenFront, 0F, 0F, 0F);
+        Keyboard = new ModelRenderer(this, 0, 47);
+        Keyboard.addBox(0F, 0F, 0F, 8, 1, 3);
+        Keyboard.setRotationPoint(-4F, 18F, -8F);
+        Keyboard.setTextureSize(128, 128);
+        Keyboard.mirror = true;
+        setRotation(Keyboard, 0.4363323F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        Tower.render(size);
+        TowerTop.render(size);
+        TopPanel.render(size);
+        Vibrator.render(size);
+        PoleBR.render(size);
+        PoleLB.render(size);
+        PoleFL.render(size);
+        PoleRF.render(size);
+        PoleL.render(size);
+        PoleR.render(size);
+        Cable.render(size);
+        ScreenFront.render(size);
+
+        GL11.glScalef(1.01F, 1.01F, 1.01F);
+        Keyboard.render(size);
+    }
+
+    @Override
+    public void renderWithPiston(float piston, float size) {
+        Vibrator.rotationPointY = 19 - (piston * 7);
+        render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacySeismicVibrator.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return on ? "LegacySeismicVibratorOn.png" : this.getTextureName();
+    }
+}

src/main/java/mekanism/client/model/ModelChargepad.java

@@ -2,17 +2,17 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
-import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelRenderer;
-import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.util.ResourceLocation;
 import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
-public class ModelChargepad extends ModelBase {
+public class ModelChargepad extends ModelMekanismBase {
     public static ResourceLocation OVERLAY
         = MekanismUtils.getResource(ResourceType.RENDER, "Chargepad_Overlay.png");
 
@@ -72,13 +72,14 @@ public class ModelChargepad extends ModelBase {
         setRotation(pillar1, 0F, 0F, 0F);
     }
 
-    public void render(float size, TextureManager manager) {
+    @Override
+    public void render(float size) {
         GL11.glPushMatrix();
         MekanismRenderer.blendOn();
 
         doRender(size);
 
-        manager.bindTexture(OVERLAY);
+        Minecraft.getMinecraft().renderEngine.bindTexture(OVERLAY);
         GL11.glScalef(1.001F, 1.001F, 1.001F);
         GL11.glTranslatef(0, -0.0011F, 0);
         MekanismRenderer.glowOn();
@@ -105,4 +106,9 @@ public class ModelChargepad extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "Chargepad.png";
+    }
 }

src/main/java/mekanism/client/model/ModelChemicalCrystallizer.java

@@ -2,12 +2,12 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
-import net.minecraft.client.model.ModelBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelChemicalCrystallizer extends ModelBase {
+public class ModelChemicalCrystallizer extends ModelMekanismBase {
     ModelRenderer tray;
     ModelRenderer support4;
     ModelRenderer rimBack;
@@ -134,6 +134,7 @@ public class ModelChemicalCrystallizer extends ModelBase {
         setRotation(Shape1, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         MekanismRenderer.blendOn();
 
@@ -163,4 +164,9 @@ public class ModelChemicalCrystallizer extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ChemicalCrystallizer.png";
+    }
 }

src/main/java/mekanism/client/model/ModelChemicalDissolutionChamber.java

@@ -2,12 +2,12 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
-import net.minecraft.client.model.ModelBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelChemicalDissolutionChamber extends ModelBase {
+public class ModelChemicalDissolutionChamber extends ModelMekanismBase {
     ModelRenderer support2;
     ModelRenderer vat5;
     ModelRenderer top2;
@@ -225,6 +225,7 @@ public class ModelChemicalDissolutionChamber extends ModelBase {
         setRotation(portToggle2, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         MekanismRenderer.blendOn();
 
@@ -267,4 +268,9 @@ public class ModelChemicalDissolutionChamber extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ChamicalDissolutionChamber.png";
+    }
 }

src/main/java/mekanism/client/model/ModelChemicalInfuser.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelChemicalInfuser extends ModelBase {
+public class ModelChemicalInfuser extends ModelMekanismBase implements IModelGlass {
     ModelRenderer base;
     ModelRenderer tank2;
     ModelRenderer portRight;
@@ -217,6 +217,7 @@ public class ModelChemicalInfuser extends ModelBase {
         setRotation(exhaust1, 0.3490659F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         base.render(size);
         tank2.render(size);
@@ -254,4 +255,14 @@ public class ModelChemicalInfuser extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ChemicalInfuser.png";
+    }
+
+    @Override
+    public void renderGlass(float size) {
+        // never called on this model
+    }
 }

src/main/java/mekanism/client/model/ModelChemicalOxidizer.java

@@ -2,11 +2,12 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelChemicalOxidizer extends ModelBase {
+public class ModelChemicalOxidizer
+    extends ModelMekanismBase implements IModelGlass {
     ModelRenderer stand;
     ModelRenderer tank;
     ModelRenderer pipe2;
@@ -84,6 +85,7 @@ public class ModelChemicalOxidizer extends ModelBase {
         setRotation(connectorToggle, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         stand.render(size);
         tank.render(size);
@@ -102,4 +104,14 @@ public class ModelChemicalOxidizer extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
-}
+
+    @Override
+    public String getTextureName() {
+        return "ChemicalOxidizer.png";
+    }
+
+    @Override
+    public void renderGlass(float size) {
+        // this is never called on the new model
+    }
+}

src/main/java/mekanism/client/model/ModelChemicalWasher.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelChemicalWasher extends ModelBase {
+public class ModelChemicalWasher extends ModelMekanismBase {
     ModelRenderer tankBack;
     ModelRenderer base;
     ModelRenderer portTop;
@@ -175,6 +175,7 @@ public class ModelChemicalWasher extends ModelBase {
         setRotation(tubeLeft3, 0F, 0F, -0.8203047F);
     }
 
+    @Override
     public void render(float size) {
         tankBack.render(size);
         base.render(size);
@@ -206,4 +207,9 @@ public class ModelChemicalWasher extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ChemicalWasher.png";
+    }
 }

src/main/java/mekanism/client/model/ModelDigitalMiner.java

@@ -2,17 +2,17 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
-import net.minecraft.client.model.ModelBase;
 import net.minecraft.client.model.ModelRenderer;
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.util.ResourceLocation;
 import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
-public class ModelDigitalMiner extends ModelBase {
+public class ModelDigitalMiner extends ModelMekanismBase implements IModelOnOff {
     public static ResourceLocation OVERLAY_ON
         = MekanismUtils.getResource(ResourceType.RENDER, "DigitalMiner_OverlayOn.png");
     public static ResourceLocation OVERLAY_OFF
@@ -420,25 +420,27 @@ public class ModelDigitalMiner extends ModelBase {
         setRotation(monitor3, 0.0872665F, 0.2094395F, 0F);
     }
 
+    @Override
     public void render(float size, boolean on, TextureManager manager) {
         GL11.glPushMatrix();
         MekanismRenderer.blendOn();
 
-        doRender(size);
+        render(size);
 
         manager.bindTexture(on ? OVERLAY_ON : OVERLAY_OFF);
         GL11.glScalef(1.001F, 1.001F, 1.001F);
         GL11.glTranslatef(0, -0.0011F, 0);
         MekanismRenderer.glowOn();
 
-        doRender(size);
+        render(size);
 
         MekanismRenderer.glowOff();
         MekanismRenderer.blendOff();
         GL11.glPopMatrix();
     }
 
-    private void doRender(float size) {
+    @Override
+    public void render(float size) {
         keyboard.render(size);
         keyboardBottom.render(size);
         keyboardSupportExt1.render(size);
@@ -502,4 +504,9 @@ public class ModelDigitalMiner extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "DigitalMiner.png";
+    }
 }

src/main/java/mekanism/client/model/ModelElectricPump.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelElectricPump extends ModelBase {
+public class ModelElectricPump extends ModelMekanismBase {
     ModelRenderer pumpRingTop;
     ModelRenderer pumpPortTop;
     ModelRenderer pumpCasing;
@@ -154,6 +154,7 @@ public class ModelElectricPump extends ModelBase {
         setRotation(pumpPipe, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         pumpRingTop.render(size);
         pumpPortTop.render(size);
@@ -182,4 +183,9 @@ public class ModelElectricPump extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ElectricPump.png";
+    }
 }

src/main/java/mekanism/client/model/ModelElectrolyticSeparator.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelElectrolyticSeparator extends ModelBase {
+public class ModelElectrolyticSeparator extends ModelMekanismBase {
     ModelRenderer tank2;
     ModelRenderer tank1;
     ModelRenderer tank3;
@@ -133,6 +133,7 @@ public class ModelElectrolyticSeparator extends ModelBase {
         setRotation(portToggle4b, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         tank2.render(size);
         tank1.render(size);
@@ -158,4 +159,9 @@ public class ModelElectrolyticSeparator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "ElectrolyticSeparator.png";
+    }
 }

src/main/java/mekanism/client/model/ModelEnergyCube.java

@@ -2,13 +2,14 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
-import mekanism.client.render.tileentity.RenderEnergyCube;
 import mekanism.common.SideData.IOState;
+import mekanism.common.Tier.BaseTier;
 import mekanism.common.Tier.EnergyCubeTier;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
-import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelRenderer;
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.util.ResourceLocation;
@@ -16,7 +17,7 @@ import net.minecraftforge.common.util.ForgeDirection;
 import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
-public class ModelEnergyCube extends ModelBase {
+public class ModelEnergyCube extends ModelMekanismBase implements IModelEnergyCube {
     public static ResourceLocation OVERLAY_ON
         = MekanismUtils.getResource(ResourceType.RENDER, "EnergyCube_OverlayOn.png");
     public static ResourceLocation OVERLAY_OFF
@@ -354,6 +355,11 @@ public class ModelEnergyCube extends ModelBase {
                                            connectorLeftToggle,   connectorRightToggle };
     }
 
+    @Override
+    public void render(float size, BaseTier tier, TextureManager manager) {
+        this.render(size, BaseTier.values()[tier.ordinal()], manager);
+    }
+
     public void render(float size, EnergyCubeTier tier, TextureManager manager) {
         frame12.render(size);
         frame11.render(size);
@@ -380,7 +386,9 @@ public class ModelEnergyCube extends ModelBase {
         GL11.glPushMatrix();
         GL11.glScalef(1.0001F, 1.0001F, 1.0001F);
         GL11.glTranslatef(0, -0.00011F, 0);
-        manager.bindTexture(RenderEnergyCube.resources.get(tier));
+        manager.bindTexture(MekanismUtils.getResource(
+            ResourceType.RENDER, this.getTextureNameForTier(tier.getBaseTier())
+        ));
         MekanismRenderer.glowOn();
 
         corner8.render(size);
@@ -396,6 +404,7 @@ public class ModelEnergyCube extends ModelBase {
         GL11.glPopMatrix();
     }
 
+    @Override
     public void renderSide(
         float size,
         ForgeDirection side,
@@ -409,7 +418,9 @@ public class ModelEnergyCube extends ModelBase {
 
             if (state == IOState.OUTPUT) {
                 MekanismRenderer.glowOn();
-                renderer.bindTexture(RenderEnergyCube.resources.get(tier));
+                renderer.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, this.getTextureNameForTier(tier.getBaseTier())
+                ));
 
                 ports[side.ordinal()].render(size);
 
@@ -437,7 +448,22 @@ public class ModelEnergyCube extends ModelBase {
         model.rotateAngleZ = z;
     }
 
-    public static class ModelEnergyCore extends ModelBase {
+    @Override
+    public String getTextureName() {
+        return "EnergyCube.png";
+    }
+
+    @Override
+    public String getTextureNameForTier(BaseTier tier) {
+        return this.getTextureName();
+    }
+
+    @Override
+    public void render(float size) {
+        this.render(size, EnergyCubeTier.BASIC, Minecraft.getMinecraft().renderEngine);
+    }
+
+    public static class ModelEnergyCore extends ModelMekanismBase {
         private ModelRenderer cube;
 
         public ModelEnergyCore() {
@@ -450,8 +476,14 @@ public class ModelEnergyCube extends ModelBase {
             cube.mirror = true;
         }
 
+        @Override
         public void render(float size) {
             cube.render(0.0625F);
         }
+
+        @Override
+        public String getTextureName() {
+            return "EnergyCore.png";
+        }
     }
 }

src/main/java/mekanism/client/model/ModelFluidicPlenisher.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelFluidicPlenisher extends ModelBase {
+public class ModelFluidicPlenisher extends ModelMekanismBase {
     ModelRenderer bearingRight;
     ModelRenderer ringTank;
     ModelRenderer portTop;
@@ -119,6 +119,7 @@ public class ModelFluidicPlenisher extends ModelBase {
         setRotation(rod1, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         bearingRight.render(size);
         ringTank.render(size);
@@ -142,4 +143,9 @@ public class ModelFluidicPlenisher extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "FluidicPlenisher.png";
+    }
 }

src/main/java/mekanism/client/model/ModelGasTank.java

@@ -2,11 +2,12 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
+import mekanism.common.Tier.BaseTier;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelGasTank extends ModelBase {
+public class ModelGasTank extends ModelMekanismBase implements IModelTier {
     ModelRenderer rim4;
     ModelRenderer rim5;
     ModelRenderer rim2;
@@ -85,6 +86,7 @@ public class ModelGasTank extends ModelBase {
         setRotation(rim1, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         rim4.render(size);
         rim5.render(size);
@@ -103,4 +105,14 @@ public class ModelGasTank extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return this.getTextureNameForTier(BaseTier.BASIC);
+    }
+
+    @Override
+    public String getTextureNameForTier(BaseTier tier) {
+        return "GasTank" + tier.getName() + ".png";
+    }
 }

src/main/java/mekanism/client/model/ModelLogisticalSorter.java

@@ -2,12 +2,14 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
-import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.texture.TextureManager;
 
 @SideOnly(Side.CLIENT)
-public class ModelLogisticalSorter extends ModelBase {
+public class ModelLogisticalSorter extends ModelMekanismBase implements IModelOnOff {
     ModelRenderer portBack;
     ModelRenderer portBackLarge;
     ModelRenderer connectorBack;
@@ -197,7 +199,8 @@ public class ModelLogisticalSorter extends ModelBase {
         setRotation(panel1, 0F, 0F, 0F);
     }
 
-    public void render(float size, boolean active) {
+    @Override
+    public void render(float size, boolean active, TextureManager renderer) {
         portBack.render(size);
         portBackLarge.render(size);
         connectorBack.render(size);
@@ -241,4 +244,19 @@ public class ModelLogisticalSorter extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "LogisticalSorter.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return on ? "LogisticalSorterOn.png" : this.getTextureName();
+    }
+
+    @Override
+    public void render(float size) {
+        this.render(size, false, Minecraft.getMinecraft().renderEngine);
+    }
 }

src/main/java/mekanism/client/model/ModelMetallurgicInfuser.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelMetallurgicInfuser extends ModelBase {
+public class ModelMetallurgicInfuser extends ModelMekanismBase {
     ModelRenderer base;
     ModelRenderer back;
     ModelRenderer connector1;
@@ -133,6 +133,7 @@ public class ModelMetallurgicInfuser extends ModelBase {
         setRotation(bar2, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         base.render(size);
         back.render(size);
@@ -158,4 +159,9 @@ public class ModelMetallurgicInfuser extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "MetallurgicInfuser.png";
+    }
 }

src/main/java/mekanism/client/model/ModelPressurizedReactionChamber.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelPressurizedReactionChamber extends ModelBase {
+public class ModelPressurizedReactionChamber extends ModelMekanismBase {
     ModelRenderer frontDivider1;
     ModelRenderer base;
     ModelRenderer front;
@@ -84,6 +84,7 @@ public class ModelPressurizedReactionChamber extends ModelBase {
         setRotation(frontDivider2, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         frontDivider1.render(size);
         base.render(size);
@@ -102,4 +103,9 @@ public class ModelPressurizedReactionChamber extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "PressurizedReactionChamber.png";
+    }
 }

src/main/java/mekanism/client/model/ModelRotaryCondensentrator.java

@@ -2,11 +2,11 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelRotaryCondensentrator extends ModelBase {
+public class ModelRotaryCondensentrator extends ModelMekanismBase {
     ModelRenderer portRight;
     ModelRenderer tankRight;
     ModelRenderer base;
@@ -168,6 +168,7 @@ public class ModelRotaryCondensentrator extends ModelBase {
         setRotation(support1, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         portRight.render(size);
         tankRight.render(size);
@@ -198,4 +199,9 @@ public class ModelRotaryCondensentrator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "RotaryCondensentrator.png";
+    }
 }

src/main/java/mekanism/client/model/ModelSeismicVibrator.java

@@ -2,11 +2,12 @@ package mekanism.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelSeismicVibrator extends ModelBase {
+public class ModelSeismicVibrator
+    extends ModelMekanismBase implements IModelSeismicVibrator {
     ModelRenderer plate3;
     ModelRenderer baseBack;
     ModelRenderer motor;
@@ -329,6 +330,7 @@ public class ModelSeismicVibrator extends ModelBase {
         setRotation(rivet9, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         plate3.render(size);
         baseBack.render(size);
@@ -377,6 +379,7 @@ public class ModelSeismicVibrator extends ModelBase {
         rivet9.render(size);
     }
 
+    @Override
     public void renderWithPiston(float piston, float size) {
         shaft1.rotationPointY = 6 - (piston * 12);
         plate2.rotationPointY = 21 - (piston * 12);
@@ -390,4 +393,17 @@ public class ModelSeismicVibrator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "SeismicVibrator.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        // The on texture is unfinished, the mod files still have the legacy texture.
+        //return on ? "SeismicVibratorOn.png" : this.getTextureName();
+
+        return this.getTextureName();
+    }
 }

src/main/java/mekanism/client/render/block/MachineRenderingHandler.java

@@ -3,7 +3,25 @@ package mekanism.client.render.block;
 import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
 import mekanism.client.ClientProxy;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelOnOff;
+import mekanism.client.model.LegacyModelChargepad;
+import mekanism.client.model.LegacyModelChemicalCrystallizer;
+import mekanism.client.model.LegacyModelChemicalDissolutionChamber;
+import mekanism.client.model.LegacyModelChemicalInfuser;
+import mekanism.client.model.LegacyModelChemicalOxidizer;
+import mekanism.client.model.LegacyModelChemicalWasher;
+import mekanism.client.model.LegacyModelDigitalMiner;
+import mekanism.client.model.LegacyModelElectricPump;
+import mekanism.client.model.LegacyModelElectrolyticSeparator;
+import mekanism.client.model.LegacyModelFluidicPlenisher;
+import mekanism.client.model.LegacyModelLogisticalSorter;
+import mekanism.client.model.LegacyModelMetallurgicInfuser;
+import mekanism.client.model.LegacyModelPressurizedReactionChamber;
+import mekanism.client.model.LegacyModelRotaryCondensentrator;
+import mekanism.client.model.LegacyModelSeismicVibrator;
 import mekanism.client.model.ModelChargepad;
 import mekanism.client.model.ModelChemicalCrystallizer;
 import mekanism.client.model.ModelChemicalDissolutionChamber;
@@ -39,33 +57,90 @@ import org.lwjgl.opengl.GL11;
 public class MachineRenderingHandler implements ISimpleBlockRenderingHandler {
     private Minecraft mc = Minecraft.getMinecraft();
 
-    public ModelElectricPump electricPump = new ModelElectricPump();
-    public ModelMetallurgicInfuser metallurgicInfuser = new ModelMetallurgicInfuser();
-    public ModelChargepad chargepad = new ModelChargepad();
-    public ModelLogisticalSorter logisticalSorter = new ModelLogisticalSorter();
-    public ModelDigitalMiner digitalMiner = new ModelDigitalMiner();
-    public ModelRotaryCondensentrator rotaryCondensentrator
-        = new ModelRotaryCondensentrator();
-    public ModelChemicalOxidizer chemicalOxidizer = new ModelChemicalOxidizer();
-    public ModelChemicalInfuser chemicalInfuser = new ModelChemicalInfuser();
-    public ModelElectrolyticSeparator electrolyticSeparator
-        = new ModelElectrolyticSeparator();
-    public ModelChemicalDissolutionChamber chemicalDissolutionChamber
-        = new ModelChemicalDissolutionChamber();
-    public ModelChemicalWasher chemicalWasher = new ModelChemicalWasher();
-    public ModelChemicalCrystallizer chemicalCrystallizer
-        = new ModelChemicalCrystallizer();
-    public ModelSeismicVibrator seismicVibrator = new ModelSeismicVibrator();
-    public ModelPressurizedReactionChamber pressurizedReactionChamber
-        = new ModelPressurizedReactionChamber();
-    public ModelFluidicPlenisher fluidicPlenisher = new ModelFluidicPlenisher();
+    public ModelMekanismBase electricPump = MekanismConfig.client.modelType.createModel(
+        ModelElectricPump::new, LegacyModelElectricPump::new
+    );
+
+    public ModelMekanismBase metallurgicInfuser
+        = MekanismConfig.client.modelType.createModel(
+            ModelMetallurgicInfuser::new, LegacyModelMetallurgicInfuser::new
+        );
+
+    public ModelMekanismBase chargepad = MekanismConfig.client.modelType.createModel(
+        ModelChargepad::new, LegacyModelChargepad::new
+    );
+
+    public IModelOnOff logisticalSorter = MekanismConfig.client.modelType.createModel(
+        ModelLogisticalSorter::new, LegacyModelLogisticalSorter::new
+    );
+
+    public IModelOnOff digitalMiner = MekanismConfig.client.modelType.createModel(
+        ModelDigitalMiner::new, LegacyModelDigitalMiner::new
+    );
+
+    public ModelMekanismBase rotaryCondensentrator
+        = MekanismConfig.client.modelType.createModel(
+            ModelRotaryCondensentrator::new, LegacyModelRotaryCondensentrator::new
+        );
+
+    public ModelMekanismBase chemicalOxidizer
+        = MekanismConfig.client.modelType.createModel(
+            ModelChemicalOxidizer::new, LegacyModelChemicalOxidizer::new
+        );
+
+    public ModelMekanismBase chemicalInfuser
+        = MekanismConfig.client.modelType.createModel(
+            ModelChemicalInfuser::new, LegacyModelChemicalInfuser::new
+        );
+
+    public ModelMekanismBase electrolyticSeparator
+        = MekanismConfig.client.modelType.createModel(
+            ModelElectrolyticSeparator::new, LegacyModelElectrolyticSeparator::new
+        );
+
+    public ModelMekanismBase chemicalDissolutionChamber
+        = MekanismConfig.client.modelType.createModel(
+            ModelChemicalDissolutionChamber::new,
+            LegacyModelChemicalDissolutionChamber::new
+        );
+
+    public ModelMekanismBase chemicalWasher = MekanismConfig.client.modelType.createModel(
+        ModelChemicalWasher::new, LegacyModelChemicalWasher::new
+    );
+
+    public ModelMekanismBase chemicalCrystallizer
+        = MekanismConfig.client.modelType.createModel(
+            ModelChemicalCrystallizer::new, LegacyModelChemicalCrystallizer::new
+        );
+
+    public ModelMekanismBase seismicVibrator
+        = MekanismConfig.client.modelType.createModel(
+            ModelSeismicVibrator::new, LegacyModelSeismicVibrator::new
+        );
+
+    public ModelMekanismBase pressurizedReactionChamber
+        = MekanismConfig.client.modelType.createModel(
+            ModelPressurizedReactionChamber::new,
+            LegacyModelPressurizedReactionChamber::new
+        );
+
+    public ModelMekanismBase fluidicPlenisher
+        = MekanismConfig.client.modelType.createModel(
+            ModelFluidicPlenisher::new, LegacyModelFluidicPlenisher::new
+        );
+
     public ModelLaser laser = new ModelLaser();
+
     public ModelLaserAmplifier laserAmplifier = new ModelLaserAmplifier();
+
     public ModelSolarNeutronActivator solarNeutronActivator
         = new ModelSolarNeutronActivator();
+
     public ModelResistiveHeater resistiveHeater = new ModelResistiveHeater();
+
     public ModelQuantumEntangloporter quantumEntangloporter
         = new ModelQuantumEntangloporter();
+
     public ModelTheoreticalElementizer theoreticalElementizer
         = new ModelTheoreticalElementizer();
 
@@ -85,71 +160,71 @@ public class MachineRenderingHandler implements ISimpleBlockRenderingHandler {
         if (type == MachineType.ELECTRIC_PUMP) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glTranslatef(0.0F, -0.85F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "ElectricPump.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, electricPump.getTextureName()
+            ));
             electricPump.render(0.0560F);
         } else if (type == MachineType.METALLURGIC_INFUSER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.0F, -1.0F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "MetallurgicInfuser.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, metallurgicInfuser.getTextureName()
+            ));
             metallurgicInfuser.render(0.0625F);
         } else if (type == MachineType.CHARGEPAD) {
             GL11.glRotatef(180F, 1.0F, 0.0F, 0.0F);
             GL11.glTranslatef(0.0F, -1.1F, 0.0F);
             mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "Chargepad.png")
+                MekanismUtils.getResource(ResourceType.RENDER, chargepad.getTextureName())
             );
-            chargepad.render(0.0625F, mc.renderEngine);
+            chargepad.render(0.0625F);
         } else if (type == MachineType.LOGISTICAL_SORTER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
             GL11.glTranslatef(0.0F, -1.0F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "LogisticalSorter.png")
-            );
-            logisticalSorter.render(0.0625F, false);
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, logisticalSorter.getTextureName()
+            ));
+            logisticalSorter.render(0.0625F, false, mc.renderEngine);
         } else if (type == MachineType.DIGITAL_MINER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(-180F, 0.0F, 1.0F, 0.0F);
             GL11.glTranslatef(0.35F, 0.1F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "DigitalMiner.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, digitalMiner.getTextureName()
+            ));
             digitalMiner.render(0.022F, false, mc.renderEngine);
         } else if (type == MachineType.ROTARY_CONDENSENTRATOR) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.05F, -0.96F, 0.05F);
             mc.renderEngine.bindTexture(MekanismUtils.getResource(
-                ResourceType.RENDER, "RotaryCondensentrator.png"
+                ResourceType.RENDER, rotaryCondensentrator.getTextureName()
             ));
             rotaryCondensentrator.render(0.0625F);
         } else if (type == MachineType.CHEMICAL_OXIDIZER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
             GL11.glTranslatef(0.0F, -1.00F, 0.05F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "ChemicalOxidizer.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, chemicalOxidizer.getTextureName()
+            ));
             chemicalOxidizer.render(0.0625F);
         } else if (type == MachineType.CHEMICAL_INFUSER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180f, 0.0F, 1.0F, 0.0F);
             GL11.glTranslatef(0.0F, -0.96F, 0.05F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "ChemicalInfuser.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, chemicalInfuser.getTextureName()
+            ));
             chemicalInfuser.render(0.0625F);
         } else if (type == MachineType.ELECTROLYTIC_SEPARATOR) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(-90F, 0.0F, 1.0F, 0.0F);
             GL11.glTranslated(0.0F, -1.0F, 0.0F);
             mc.renderEngine.bindTexture(MekanismUtils.getResource(
-                ResourceType.RENDER, "ElectrolyticSeparator.png"
+                ResourceType.RENDER, electrolyticSeparator.getTextureName()
             ));
             electrolyticSeparator.render(0.0625F);
         } else if (type == MachineType.CHEMICAL_DISSOLUTION_CHAMBER) {
@@ -157,49 +232,49 @@ public class MachineRenderingHandler implements ISimpleBlockRenderingHandler {
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.05F, -0.96F, 0.05F);
             mc.renderEngine.bindTexture(MekanismUtils.getResource(
-                ResourceType.RENDER, "ChemicalDissolutionChamber.png"
+                ResourceType.RENDER, chemicalDissolutionChamber.getTextureName()
             ));
             chemicalDissolutionChamber.render(0.0625F);
         } else if (type == MachineType.CHEMICAL_WASHER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.05F, -0.96F, 0.05F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "ChemicalWasher.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, chemicalWasher.getTextureName()
+            ));
             chemicalWasher.render(0.0625F);
         } else if (type == MachineType.CHEMICAL_CRYSTALLIZER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.05F, -0.96F, 0.05F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "ChemicalCrystallizer.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, chemicalCrystallizer.getTextureName()
+            ));
             chemicalCrystallizer.render(0.0625F);
         } else if (type == MachineType.SEISMIC_VIBRATOR) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glScalef(0.6F, 0.6F, 0.6F);
             GL11.glTranslatef(0.0F, -0.55F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "SeismicVibrator.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, seismicVibrator.getTextureName()
+            ));
             seismicVibrator.render(0.0625F);
         } else if (type == MachineType.PRESSURIZED_REACTION_CHAMBER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.05F, -0.96F, 0.05F);
             mc.renderEngine.bindTexture(MekanismUtils.getResource(
-                ResourceType.RENDER, "PressurizedReactionChamber.png"
+                ResourceType.RENDER, pressurizedReactionChamber.getTextureName()
             ));
             pressurizedReactionChamber.render(0.0625F);
         } else if (type == MachineType.FLUIDIC_PLENISHER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(180F, 0.0F, -1.0F, 0.0F);
             GL11.glTranslatef(0.0F, -0.85F, 0.0F);
-            mc.renderEngine.bindTexture(
-                MekanismUtils.getResource(ResourceType.RENDER, "FluidicPlenisher.png")
-            );
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, fluidicPlenisher.getTextureName()
+            ));
             fluidicPlenisher.render(0.0560F);
         } else if (type == MachineType.LASER) {
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

src/main/java/mekanism/client/render/item/ItemRenderingHandler.java

@@ -4,9 +4,14 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 import mekanism.api.EnumColor;
+import mekanism.api.MekanismConfig;
 import mekanism.api.energy.IEnergizedItem;
 import mekanism.client.ClientProxy;
 import mekanism.client.MekanismClient;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelEnergyCube;
+import mekanism.client.model.LegacyModelEnergyCube;
+import mekanism.client.model.LegacyModelGasTank;
 import mekanism.client.model.ModelArmoredJetpack;
 import mekanism.client.model.ModelAtomicDisassembler;
 import mekanism.client.model.ModelEnergyCube;
@@ -24,7 +29,6 @@ import mekanism.client.render.RenderGlowPanel;
 import mekanism.client.render.RenderPartTransmitter;
 import mekanism.client.render.entity.RenderBalloon;
 import mekanism.client.render.tileentity.RenderBin;
-import mekanism.client.render.tileentity.RenderEnergyCube;
 import mekanism.client.render.tileentity.RenderFluidTank;
 import mekanism.common.MekanismBlocks;
 import mekanism.common.MekanismItems;
@@ -78,9 +82,15 @@ public class ItemRenderingHandler implements IItemRenderer {
 
     public ModelRobit robit = new ModelRobit();
     public ModelChest personalChest = new ModelChest();
-    public ModelEnergyCube energyCube = new ModelEnergyCube();
-    public ModelEnergyCore energyCore = new ModelEnergyCore();
-    public ModelGasTank gasTank = new ModelGasTank();
+    public IModelEnergyCube energyCube = MekanismConfig.client.modelType.createModel(
+        ModelEnergyCube::new, LegacyModelEnergyCube::new
+    );
+    public ModelMekanismBase energyCore = MekanismConfig.client.modelType.createModel(
+        ModelEnergyCore::new, LegacyModelEnergyCube.LegacyModelEnergyCore::new
+    );
+    public ModelMekanismBase gasTank = MekanismConfig.client.modelType.createModel(
+        ModelGasTank::new, LegacyModelGasTank::new
+    );
     public ModelObsidianTNT obsidianTNT = new ModelObsidianTNT();
     public ModelJetpack jetpack = new ModelJetpack();
     public ModelArmoredJetpack armoredJetpack = new ModelArmoredJetpack();
@@ -117,8 +127,6 @@ public class ItemRenderingHandler implements IItemRenderer {
 
     @Override
     public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
-        RenderBlocks renderBlocks = (RenderBlocks) data[0];
-
         if (type == ItemRenderType.EQUIPPED
             || type == ItemRenderType.EQUIPPED_FIRST_PERSON) {
             GL11.glTranslatef(0.5F, 0.5F, 0.5F);
@@ -127,7 +135,9 @@ public class ItemRenderingHandler implements IItemRenderer {
         if (item.getItem() instanceof IEnergyCube) {
             EnergyCubeTier tier = ((IEnergyCube) item.getItem()).getEnergyCubeTier(item);
             IEnergizedItem energized = (IEnergizedItem) item.getItem();
-            mc.renderEngine.bindTexture(RenderEnergyCube.baseTexture);
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, energyCube.getTextureNameForTier(tier.getBaseTier())
+            ));
 
             GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
             GL11.glRotatef(270F, 0.0F, -1.0F, 0.0F);
@@ -135,10 +145,13 @@ public class ItemRenderingHandler implements IItemRenderer {
 
             MekanismRenderer.blendOn();
 
-            energyCube.render(0.0625F, tier, mc.renderEngine);
+            energyCube.render(0.0625F, tier.getBaseTier(), mc.renderEngine);
 
             for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
-                mc.renderEngine.bindTexture(RenderEnergyCube.baseTexture);
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER,
+                    energyCube.getTextureNameForTier(tier.getBaseTier())
+                ));
                 energyCube.renderSide(
                     0.0625F,
                     side,
@@ -152,7 +165,9 @@ public class ItemRenderingHandler implements IItemRenderer {
 
             GL11.glPushMatrix();
             GL11.glTranslated(0.0, 1.0, 0.0);
-            mc.renderEngine.bindTexture(RenderEnergyCube.coreTexture);
+            mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                ResourceType.RENDER, energyCore.getTextureName()
+            ));
 
             GL11.glShadeModel(GL11.GL_SMOOTH);
             GL11.glEnable(GL11.GL_BLEND);

src/main/java/mekanism/client/render/tileentity/RenderChargepad.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelChargepad;
 import mekanism.client.model.ModelChargepad;
 import mekanism.common.tile.TileEntityChargepad;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderChargepad extends TileEntitySpecialRenderer {
-    private ModelChargepad model = new ModelChargepad();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelChargepad::new, LegacyModelChargepad::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -26,7 +31,8 @@ public class RenderChargepad extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "Chargepad.png"));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
         switch (tileEntity.facing) {
             case 2:
@@ -44,7 +50,7 @@ public class RenderChargepad extends TileEntitySpecialRenderer {
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
-        model.render(0.0625F, field_147501_a.field_147553_e);
+        model.render(0.0625F);
         GL11.glPopMatrix();
     }
 }

src/main/java/mekanism/client/render/tileentity/RenderChemicalCrystallizer.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelChemicalCrystallizer;
 import mekanism.client.model.ModelChemicalCrystallizer;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.tile.TileEntityChemicalCrystallizer;
@@ -13,7 +16,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderChemicalCrystallizer extends TileEntitySpecialRenderer {
-    private ModelChemicalCrystallizer model = new ModelChemicalCrystallizer();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelChemicalCrystallizer::new, LegacyModelChemicalCrystallizer::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -31,11 +36,10 @@ public class RenderChemicalCrystallizer extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(
-            MekanismUtils.getResource(ResourceType.RENDER, "ChemicalCrystallizer.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/client/render/tileentity/RenderChemicalDissolutionChamber.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelChemicalDissolutionChamber;
 import mekanism.client.model.ModelChemicalDissolutionChamber;
 import mekanism.common.tile.TileEntityChemicalDissolutionChamber;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderChemicalDissolutionChamber extends TileEntitySpecialRenderer {
-    private ModelChemicalDissolutionChamber model = new ModelChemicalDissolutionChamber();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelChemicalDissolutionChamber::new, LegacyModelChemicalDissolutionChamber::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -32,11 +37,10 @@ public class RenderChemicalDissolutionChamber extends TileEntitySpecialRenderer
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(
-            ResourceType.RENDER, "ChemicalDissolutionChamber.png"
-        ));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/client/render/tileentity/RenderChemicalInfuser.java

@@ -1,15 +1,34 @@
 package mekanism.client.render.tileentity;
 
+import java.util.HashMap;
+import java.util.Map;
+
+import mekanism.api.MekanismConfig;
+import mekanism.api.gas.Gas;
+import mekanism.client.model.IModelGlass;
+import mekanism.client.model.LegacyModelChemicalInfuser;
 import mekanism.client.model.ModelChemicalInfuser;
+import mekanism.client.render.MekanismRenderer;
+import mekanism.client.render.MekanismRenderer.DisplayInteger;
+import mekanism.client.render.MekanismRenderer.Model3D;
 import mekanism.common.tile.TileEntityChemicalInfuser;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.init.Blocks;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
 import org.lwjgl.opengl.GL11;
 
 public class RenderChemicalInfuser extends TileEntitySpecialRenderer {
-    private ModelChemicalInfuser model = new ModelChemicalInfuser();
+    private IModelGlass model = MekanismConfig.client.modelType.createModel(
+        ModelChemicalInfuser::new, LegacyModelChemicalInfuser::new
+    );
+
+    private static final double offset = 0.001;
+
+    private Map<ForgeDirection, HashMap<Gas, DisplayInteger>> cachedGasses
+        = new HashMap<ForgeDirection, HashMap<Gas, DisplayInteger>>();
 
     @Override
     public void renderTileEntityAt(
@@ -24,11 +43,110 @@ public class RenderChemicalInfuser extends TileEntitySpecialRenderer {
         double y,
         double z,
         float partialTick
+    ) {
+        if (MekanismConfig.client.modelType.isOld()) {
+            render(false, x, y, z, tileEntity);
+
+            if (tileEntity.leftTank.getGas() != null) {
+                push();
+
+                GL11.glTranslatef((float) x, (float) y, (float) z);
+                GL11.glColor4f(
+                    1.0F,
+                    1.0F,
+                    1.0F,
+                    (float) tileEntity.leftTank.getStored()
+                        / tileEntity.leftTank.getMaxGas()
+                );
+                bindTexture(MekanismRenderer.getBlocksTexture());
+                getListAndRender(
+                    ForgeDirection.getOrientation(tileEntity.facing),
+                    tileEntity.leftTank.getGas().getGas()
+                )
+                    .render();
+                GL11.glColor4f(1, 1, 1, 1);
+
+                pop();
+            }
+
+            if (tileEntity.rightTank.getGas() != null) {
+                push();
+
+                switch (ForgeDirection.getOrientation(tileEntity.facing)) {
+                    case NORTH:
+                        GL11.glTranslatef(-0.4375F, 0, 0);
+                        break;
+                    case SOUTH:
+                        GL11.glTranslatef(0.4375F, 0, 0);
+                        break;
+                    case EAST:
+                        GL11.glTranslatef(0, 0, -0.4375F);
+                        break;
+                    case WEST:
+                        GL11.glTranslatef(0, 0, 0.4375F);
+                        break;
+                }
+
+                GL11.glTranslatef((float) x, (float) y, (float) z);
+                GL11.glColor4f(
+                    1.0F,
+                    1.0F,
+                    1.0F,
+                    (float) tileEntity.rightTank.getStored()
+                        / tileEntity.rightTank.getMaxGas()
+                );
+                bindTexture(MekanismRenderer.getBlocksTexture());
+                getListAndRender(
+                    ForgeDirection.getOrientation(tileEntity.facing),
+                    tileEntity.rightTank.getGas().getGas()
+                )
+                    .render();
+                GL11.glColor4f(1, 1, 1, 1);
+
+                pop();
+            }
+
+            render(true, x, y, z, tileEntity);
+        } else {
+            GL11.glPushMatrix();
+            GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
+
+            bindTexture(
+                MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+            );
+
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
+
+            GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+            model.render(0.0625F);
+
+            GL11.glPopMatrix();
+        }
+    }
+
+    /*
+     * 0: casing, 1: glass
+     */
+    private void render(
+        boolean glass, double x, double y, double z, TileEntityChemicalInfuser tileEntity
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "ChemicalInfuser.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
         switch (tileEntity.facing) {
@@ -47,8 +165,102 @@ public class RenderChemicalInfuser extends TileEntitySpecialRenderer {
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
-        model.render(0.0625F);
+
+        if (!glass) {
+            model.render(0.0625F);
+        } else {
+            model.renderGlass(0.0625F);
+        }
 
         GL11.glPopMatrix();
     }
+
+    @SuppressWarnings("incomplete-switch")
+    private DisplayInteger getListAndRender(ForgeDirection side, Gas gas) {
+        if (gas == null || gas.getIcon() == null) {
+            return null;
+        }
+
+        if (cachedGasses.containsKey(side) && cachedGasses.get(side).containsKey(gas)) {
+            return cachedGasses.get(side).get(gas);
+        }
+
+        Model3D toReturn = new Model3D();
+        toReturn.baseBlock = Blocks.water;
+        toReturn.setTexture(gas.getIcon());
+
+        DisplayInteger display = DisplayInteger.createAndStart();
+
+        if (cachedGasses.containsKey(side)) {
+            cachedGasses.get(side).put(gas, display);
+        } else {
+            HashMap<Gas, DisplayInteger> map = new HashMap<Gas, DisplayInteger>();
+            map.put(gas, display);
+            cachedGasses.put(side, map);
+        }
+
+        switch (side) {
+            case NORTH: {
+                toReturn.minX = 0.625 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.625 + offset;
+
+                toReturn.maxX = 0.8125 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.8125 - offset;
+                break;
+            }
+            case SOUTH: {
+                toReturn.minX = 0.1875 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.1875 + offset;
+
+                toReturn.maxX = 0.375 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.375 - offset;
+                break;
+            }
+            case WEST: {
+                toReturn.minX = 0.625 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.1875 + offset;
+
+                toReturn.maxX = 0.8125 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.375 - offset;
+                break;
+            }
+            case EAST: {
+                toReturn.minX = 0.1875 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.625 + offset;
+
+                toReturn.maxX = 0.375 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.8125 - offset;
+                break;
+            }
+        }
+
+        MekanismRenderer.renderObject(toReturn);
+        DisplayInteger.endList();
+
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+
+        return display;
+    }
+
+    private void pop() {
+        GL11.glPopAttrib();
+        GL11.glPopMatrix();
+    }
+
+    private void push() {
+        GL11.glPushMatrix();
+        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+    }
 }

src/main/java/mekanism/client/render/tileentity/RenderChemicalOxidizer.java

@@ -3,19 +3,27 @@ package mekanism.client.render.tileentity;
 import java.util.HashMap;
 import java.util.Map;
 
+import mekanism.api.MekanismConfig;
 import mekanism.api.gas.Gas;
+import mekanism.client.model.IModelGlass;
+import mekanism.client.model.LegacyModelChemicalOxidizer;
 import mekanism.client.model.ModelChemicalOxidizer;
+import mekanism.client.render.MekanismRenderer;
 import mekanism.client.render.MekanismRenderer.DisplayInteger;
+import mekanism.client.render.MekanismRenderer.Model3D;
 import mekanism.common.tile.TileEntityChemicalOxidizer;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.init.Blocks;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.common.util.ForgeDirection;
 import org.lwjgl.opengl.GL11;
 
 public class RenderChemicalOxidizer extends TileEntitySpecialRenderer {
-    private ModelChemicalOxidizer model = new ModelChemicalOxidizer();
+    private IModelGlass model = MekanismConfig.client.modelType.createModel(
+        ModelChemicalOxidizer::new, LegacyModelChemicalOxidizer::new
+    );
 
     private static final double offset = 0.001;
 
@@ -35,11 +43,74 @@ public class RenderChemicalOxidizer extends TileEntitySpecialRenderer {
         double y,
         double z,
         float partialTick
+    ) {
+        if (MekanismConfig.client.modelType.isOld()) {
+            render(false, x, y, z, tileEntity);
+
+            if (tileEntity.gasTank.getGas() != null) {
+                push();
+
+                GL11.glTranslatef((float) x, (float) y, (float) z);
+                GL11.glColor4f(
+                    1.0F,
+                    1.0F,
+                    1.0F,
+                    (float) tileEntity.gasTank.getStored()
+                        / tileEntity.gasTank.getMaxGas()
+                );
+                bindTexture(MekanismRenderer.getBlocksTexture());
+                getListAndRender(
+                    ForgeDirection.getOrientation(tileEntity.facing),
+                    tileEntity.gasTank.getGas().getGas()
+                )
+                    .render();
+                GL11.glColor4f(1, 1, 1, 1);
+
+                pop();
+            }
+
+            render(true, x, y, z, tileEntity);
+        } else {
+            GL11.glPushMatrix();
+            GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
+
+            bindTexture(
+                MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+            );
+
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
+
+            GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+
+            model.render(0.0625F);
+
+            GL11.glPopMatrix();
+        }
+    }
+
+    /*
+     * 0: casing, 1: glass
+     */
+    private void render(
+        boolean glass, double x, double y, double z, TileEntityChemicalOxidizer tileEntity
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "ChemicalOxidizer.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
         switch (tileEntity.facing) {
@@ -59,8 +130,101 @@ public class RenderChemicalOxidizer extends TileEntitySpecialRenderer {
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
 
-        model.render(0.0625F);
+        if (!glass) {
+            model.render(0.0625F);
+        } else {
+            model.renderGlass(0.0625F);
+        }
 
         GL11.glPopMatrix();
     }
+
+    @SuppressWarnings("incomplete-switch")
+    private DisplayInteger getListAndRender(ForgeDirection side, Gas gas) {
+        if (gas == null || gas.getIcon() == null) {
+            return null;
+        }
+
+        if (cachedGasses.containsKey(side) && cachedGasses.get(side).containsKey(gas)) {
+            return cachedGasses.get(side).get(gas);
+        }
+
+        Model3D toReturn = new Model3D();
+        toReturn.baseBlock = Blocks.water;
+        toReturn.setTexture(gas.getIcon());
+
+        DisplayInteger display = DisplayInteger.createAndStart();
+
+        if (cachedGasses.containsKey(side)) {
+            cachedGasses.get(side).put(gas, display);
+        } else {
+            HashMap<Gas, DisplayInteger> map = new HashMap<Gas, DisplayInteger>();
+            map.put(gas, display);
+            cachedGasses.put(side, map);
+        }
+
+        switch (side) {
+            case NORTH: {
+                toReturn.minX = 0.125 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.3125 + offset;
+
+                toReturn.maxX = 0.5 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.6875 - offset;
+                break;
+            }
+            case SOUTH: {
+                toReturn.minX = 0.5 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.3125 + offset;
+
+                toReturn.maxX = 0.875 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.6875 - offset;
+                break;
+            }
+            case WEST: {
+                toReturn.minX = 0.3125 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.5 + offset;
+
+                toReturn.maxX = 0.6875 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.875 - offset;
+                break;
+            }
+            case EAST: {
+                toReturn.minX = 0.3125 + offset;
+                toReturn.minY = 0.0625 + offset;
+                toReturn.minZ = 0.125 + offset;
+
+                toReturn.maxX = 0.6875 - offset;
+                toReturn.maxY = 0.9375 - offset;
+                toReturn.maxZ = 0.5 - offset;
+                break;
+            }
+        }
+
+        MekanismRenderer.renderObject(toReturn);
+        DisplayInteger.endList();
+
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+
+        return display;
+    }
+
+    private void pop() {
+        GL11.glPopAttrib();
+        GL11.glPopMatrix();
+    }
+
+    private void push() {
+        GL11.glPushMatrix();
+        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+    }
 }

src/main/java/mekanism/client/render/tileentity/RenderChemicalWasher.java

@@ -1,5 +1,8 @@
 package mekanism.client.render.tileentity;
 
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelChemicalWasher;
 import mekanism.client.model.ModelChemicalWasher;
 import mekanism.common.tile.TileEntityChemicalWasher;
 import mekanism.common.util.MekanismUtils;
@@ -9,7 +12,9 @@ import net.minecraft.tileentity.TileEntity;
 import org.lwjgl.opengl.GL11;
 
 public class RenderChemicalWasher extends TileEntitySpecialRenderer {
-    private ModelChemicalWasher model = new ModelChemicalWasher();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelChemicalWasher::new, LegacyModelChemicalWasher::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -27,9 +32,10 @@ public class RenderChemicalWasher extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "ChemicalWasher.png"));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/client/render/tileentity/RenderDigitalMiner.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.model.IModelOnOff;
+import mekanism.client.model.LegacyModelDigitalMiner;
 import mekanism.client.model.ModelDigitalMiner;
 import mekanism.client.render.MinerVisualRenderer;
 import mekanism.common.tile.TileEntityDigitalMiner;
@@ -13,7 +16,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderDigitalMiner extends TileEntitySpecialRenderer {
-    private ModelDigitalMiner model = new ModelDigitalMiner();
+    private IModelOnOff model = MekanismConfig.client.modelType.createModel(
+        ModelDigitalMiner::new, LegacyModelDigitalMiner::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -28,32 +33,51 @@ public class RenderDigitalMiner extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "DigitalMiner.png"));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
-        switch (tileEntity.facing) {
-            case 2:
-                GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 0.0F, -1.0F);
-                break;
-            case 3:
-                GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 0.0F, -1.0F);
-                break;
-            case 4:
-                GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 0.0F, -1.0F);
-                break;
-            case 5:
-                GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 0.0F, -1.0F);
-                break;
+        // Not using mapFacing here, as this is different.
+        if (MekanismConfig.client.modelType.isOld()) {
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
+        } else {
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 0.0F, -1.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 0.0F, -1.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 0.0F, -1.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 0.0F, -1.0F);
+                    break;
+            }
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
         model.render(0.0625F, tileEntity.isActive, field_147501_a.field_147553_e);
         GL11.glPopMatrix();
 
-        if (tileEntity.clientRendering) {
+        if (!MekanismConfig.client.modelType.isOld() && tileEntity.clientRendering) {
             MinerVisualRenderer.render(tileEntity);
         }
     }

src/main/java/mekanism/client/render/tileentity/RenderElectricPump.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelElectricPump;
 import mekanism.client.model.ModelElectricPump;
 import mekanism.common.tile.TileEntityElectricPump;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderElectricPump extends TileEntitySpecialRenderer {
-    private ModelElectricPump model = new ModelElectricPump();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelElectricPump::new, LegacyModelElectricPump::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -27,9 +32,10 @@ public class RenderElectricPump extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "ElectricPump.png"));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/client/render/tileentity/RenderElectrolyticSeparator.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelElectrolyticSeparator;
 import mekanism.client.model.ModelElectrolyticSeparator;
 import mekanism.common.tile.TileEntityElectrolyticSeparator;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderElectrolyticSeparator extends TileEntitySpecialRenderer {
-    private ModelElectrolyticSeparator model = new ModelElectrolyticSeparator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelElectrolyticSeparator::new, LegacyModelElectrolyticSeparator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -32,23 +37,39 @@ public class RenderElectrolyticSeparator extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(
-            MekanismUtils.getResource(ResourceType.RENDER, "ElectrolyticSeparator.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
-        switch (tileEntity.facing) {
-            case 2:
-                GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
-                break;
-            case 3:
-                GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
-                break;
-            case 4:
-                GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
-                break;
-            case 5:
-                GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
-                break;
+        if (MekanismConfig.client.modelType.isOld()) {
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
+        } else {
+            switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java

@@ -1,22 +1,21 @@
 package mekanism.client.render.tileentity;
 
-import java.util.HashMap;
-import java.util.Map;
-
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
 import mekanism.api.transmitters.TransmissionType;
 import mekanism.client.MekanismClient;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelEnergyCube;
+import mekanism.client.model.LegacyModelEnergyCube;
 import mekanism.client.model.ModelEnergyCube;
 import mekanism.client.model.ModelEnergyCube.ModelEnergyCore;
 import mekanism.client.render.MekanismRenderer;
-import mekanism.common.Tier.EnergyCubeTier;
 import mekanism.common.tile.TileEntityEnergyCube;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.common.util.ForgeDirection;
 import org.lwjgl.opengl.GL11;
 
@@ -28,29 +27,12 @@ public class RenderEnergyCube extends TileEntitySpecialRenderer {
                                                  new int[] { 154, 120, 200 },
                                                  new int[] { 0, 0, 0 } };
 
-    private ModelEnergyCube model = new ModelEnergyCube();
-    private ModelEnergyCore core = new ModelEnergyCore();
-
-    public static Map<EnergyCubeTier, ResourceLocation> resources
-        = new HashMap<EnergyCubeTier, ResourceLocation>();
-    public static ResourceLocation baseTexture
-        = MekanismUtils.getResource(ResourceType.RENDER, "EnergyCube.png");
-    public static ResourceLocation coreTexture
-        = MekanismUtils.getResource(ResourceType.RENDER, "EnergyCore.png");
-
-    static {
-        if (resources.isEmpty()) {
-            for (EnergyCubeTier tier : EnergyCubeTier.values()) {
-                resources.put(
-                    tier,
-                    MekanismUtils.getResource(
-                        ResourceType.RENDER,
-                        "EnergyCube" + tier.getBaseTier().getName() + ".png"
-                    )
-                );
-            }
-        }
-    }
+    private IModelEnergyCube model = MekanismConfig.client.modelType.createModel(
+        ModelEnergyCube::new, LegacyModelEnergyCube::new
+    );
+    private ModelMekanismBase core = MekanismConfig.client.modelType.createModel(
+        ModelEnergyCore::new, LegacyModelEnergyCube.LegacyModelEnergyCore::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -65,7 +47,10 @@ public class RenderEnergyCube extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(baseTexture);
+        bindTexture(MekanismUtils.getResource(
+            ResourceType.RENDER,
+            model.getTextureNameForTier(tileEntity.tier.getBaseTier())
+        ));
 
         switch (tileEntity.facing) {
             case 0: {
@@ -93,19 +78,26 @@ public class RenderEnergyCube extends TileEntitySpecialRenderer {
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
-        model.render(0.0625F, tileEntity.tier, field_147501_a.field_147553_e);
+        model.render(
+            0.0625F, tileEntity.tier.getBaseTier(), field_147501_a.field_147553_e
+        );
 
-        for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
-            bindTexture(baseTexture);
-            model.renderSide(
-                0.0625F,
-                side,
-                tileEntity.configComponent
-                    .getOutput(TransmissionType.ENERGY, side.ordinal())
-                    .ioState,
-                tileEntity.tier,
-                field_147501_a.field_147553_e
-            );
+        if (!MekanismConfig.client.modelType.isOld()) {
+            for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER,
+                    model.getTextureNameForTier(tileEntity.tier.getBaseTier())
+                ));
+                model.renderSide(
+                    0.0625F,
+                    side,
+                    tileEntity.configComponent
+                        .getOutput(TransmissionType.ENERGY, side.ordinal())
+                        .ioState,
+                    tileEntity.tier,
+                    field_147501_a.field_147553_e
+                );
+            }
         }
 
         GL11.glPopMatrix();
@@ -113,7 +105,9 @@ public class RenderEnergyCube extends TileEntitySpecialRenderer {
         if (tileEntity.getEnergy() / tileEntity.getMaxEnergy() > 0.1) {
             GL11.glPushMatrix();
             GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
-            bindTexture(coreTexture);
+            bindTexture(
+                MekanismUtils.getResource(ResourceType.RENDER, core.getTextureName())
+            );
 
             MekanismRenderer.blendOn();
             MekanismRenderer.glowOn();

src/main/java/mekanism/client/render/tileentity/RenderFluidicPlenisher.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelFluidicPlenisher;
 import mekanism.client.model.ModelFluidicPlenisher;
 import mekanism.common.tile.TileEntityFluidicPlenisher;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderFluidicPlenisher extends TileEntitySpecialRenderer {
-    private ModelFluidicPlenisher model = new ModelFluidicPlenisher();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelFluidicPlenisher::new, LegacyModelFluidicPlenisher::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -31,7 +36,7 @@ public class RenderFluidicPlenisher extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "FluidicPlenisher.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
         switch (tileEntity.facing) {

src/main/java/mekanism/client/render/tileentity/RenderGasTank.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.model.IModelTier;
+import mekanism.client.model.LegacyModelGasTank;
 import mekanism.client.model.ModelGasTank;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.tile.TileEntityGasTank;
@@ -13,7 +16,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderGasTank extends TileEntitySpecialRenderer {
-    private ModelGasTank model = new ModelGasTank();
+    private IModelTier model = MekanismConfig.client.modelType.createModel(
+        ModelGasTank::new, LegacyModelGasTank::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -29,7 +34,7 @@ public class RenderGasTank extends TileEntitySpecialRenderer {
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
         bindTexture(MekanismUtils.getResource(
             ResourceType.RENDER,
-            "GasTank" + tileEntity.tier.getBaseTier().getName() + ".png"
+            model.getTextureNameForTier(tileEntity.tier.getBaseTier())
         ));
 
         switch (tileEntity.facing) {

src/main/java/mekanism/client/render/tileentity/RenderLogisticalSorter.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.model.IModelOnOff;
+import mekanism.client.model.LegacyModelLogisticalSorter;
 import mekanism.client.model.ModelLogisticalSorter;
 import mekanism.common.tile.TileEntityLogisticalSorter;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderLogisticalSorter extends TileEntitySpecialRenderer {
-    private ModelLogisticalSorter model = new ModelLogisticalSorter();
+    private IModelOnOff model = MekanismConfig.client.modelType.createModel(
+        ModelLogisticalSorter::new, LegacyModelLogisticalSorter::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -32,37 +37,63 @@ public class RenderLogisticalSorter extends TileEntitySpecialRenderer {
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
         bindTexture(MekanismUtils.getResource(
-            ResourceType.RENDER,
-            "LogisticalSorter" + (tileEntity.isActive ? "On" : "") + ".png"
+            ResourceType.RENDER, model.getTextureNameForState(tileEntity.isActive)
         ));
 
-        switch (tileEntity.facing) {
-            case 0: {
-                GL11.glRotatef(90F, -1.0F, 0.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 1.0F, -1.0F);
-                break;
+        if (MekanismConfig.client.modelType.isOld()) {
+            switch (tileEntity.facing) {
+                case 0: {
+                    GL11.glRotatef(90F, 0.0F, 0.0F, -1.0F);
+                    GL11.glTranslatef(1.0F, 1.0F, 0.0F);
+                    break;
+                }
+                case 1: {
+                    GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+                    GL11.glTranslatef(-1.0F, 1.0F, 0.0F);
+                    break;
+                }
+                case 2:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
             }
-            case 1: {
-                GL11.glRotatef(90F, 1.0F, 0.0F, 0.0F);
-                GL11.glTranslatef(0.0F, 1.0F, 1.0F);
-                break;
+        } else {
+            switch (tileEntity.facing) {
+                case 0: {
+                    GL11.glRotatef(90F, -1.0F, 0.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 1.0F, -1.0F);
+                    break;
+                }
+                case 1: {
+                    GL11.glRotatef(90F, 1.0F, 0.0F, 0.0F);
+                    GL11.glTranslatef(0.0F, 1.0F, 1.0F);
+                    break;
+                }
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
             }
-            case 2:
-                GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
-                break;
-            case 3:
-                GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
-                break;
-            case 4:
-                GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
-                break;
-            case 5:
-                GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
-                break;
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
-        model.render(0.0625F, tileEntity.isActive);
+        model.render(0.0625F, tileEntity.isActive, field_147501_a.field_147553_e);
         GL11.glPopMatrix();
     }
 }

src/main/java/mekanism/client/render/tileentity/RenderMetallurgicInfuser.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelMetallurgicInfuser;
 import mekanism.client.model.ModelMetallurgicInfuser;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.tile.TileEntityMetallurgicInfuser;
@@ -13,7 +16,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderMetallurgicInfuser extends TileEntitySpecialRenderer {
-    private ModelMetallurgicInfuser model = new ModelMetallurgicInfuser();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelMetallurgicInfuser::new, LegacyModelMetallurgicInfuser::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -32,11 +37,10 @@ public class RenderMetallurgicInfuser extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(
-            MekanismUtils.getResource(ResourceType.RENDER, "MetallurgicInfuser.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                 break;
@@ -57,4 +61,4 @@ public class RenderMetallurgicInfuser extends TileEntitySpecialRenderer {
 
         MekanismRenderer.machineRenderer.renderAModelAt(tileEntity, x, y, z, partialTick);
     }
-}
+}

src/main/java/mekanism/client/render/tileentity/RenderPressurizedReactionChamber.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelPressurizedReactionChamber;
 import mekanism.client.model.ModelPressurizedReactionChamber;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.tile.TileEntityPRC;
@@ -13,7 +16,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderPressurizedReactionChamber extends TileEntitySpecialRenderer {
-    private ModelPressurizedReactionChamber model = new ModelPressurizedReactionChamber();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelPressurizedReactionChamber::new, LegacyModelPressurizedReactionChamber::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -28,9 +33,8 @@ public class RenderPressurizedReactionChamber extends TileEntitySpecialRenderer
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(
-            ResourceType.RENDER, "PressurizedReactionChamber.png"
-        ));
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
+        );
 
         switch (tileEntity.facing) {
             case 2:
@@ -53,4 +57,4 @@ public class RenderPressurizedReactionChamber extends TileEntitySpecialRenderer
 
         MekanismRenderer.machineRenderer.renderAModelAt(tileEntity, x, y, z, partialTick);
     }
-}
+}

src/main/java/mekanism/client/render/tileentity/RenderRotaryCondensentrator.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.LegacyModelRotaryCondensentrator;
 import mekanism.client.model.ModelRotaryCondensentrator;
 import mekanism.common.tile.TileEntityRotaryCondensentrator;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderRotaryCondensentrator extends TileEntitySpecialRenderer {
-    private ModelRotaryCondensentrator model = new ModelRotaryCondensentrator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelRotaryCondensentrator::new, LegacyModelRotaryCondensentrator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -33,23 +38,39 @@ public class RenderRotaryCondensentrator extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(
-            MekanismUtils.getResource(ResourceType.RENDER, "RotaryCondensentrator.png")
+        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, model.getTextureName())
         );
 
-        switch (tileEntity.facing) {
-            case 2:
-                GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
-                break;
-            case 3:
-                GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
-                break;
-            case 4:
-                GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
-                break;
-            case 5:
-                GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
-                break;
+        if (MekanismConfig.client.modelType.isOld()) {
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
+        } else {
+            switch (tileEntity.facing) {
+                case 2:
+                    GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 3:
+                    GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 4:
+                    GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
+                    break;
+                case 5:
+                    GL11.glRotatef(270, 0.0F, 1.0F, 0.0F);
+                    break;
+            }
         }
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

src/main/java/mekanism/client/render/tileentity/RenderSeismicVibrator.java

@@ -2,6 +2,9 @@ package mekanism.client.render.tileentity;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.model.IModelSeismicVibrator;
+import mekanism.client.model.LegacyModelSeismicVibrator;
 import mekanism.client.model.ModelSeismicVibrator;
 import mekanism.common.tile.TileEntitySeismicVibrator;
 import mekanism.common.util.MekanismUtils;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderSeismicVibrator extends TileEntitySpecialRenderer {
-    private ModelSeismicVibrator model = new ModelSeismicVibrator();
+    private IModelSeismicVibrator model = MekanismConfig.client.modelType.createModel(
+        ModelSeismicVibrator::new, LegacyModelSeismicVibrator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -32,8 +37,7 @@ public class RenderSeismicVibrator extends TileEntitySpecialRenderer {
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
         bindTexture(MekanismUtils.getResource(
-            ResourceType.RENDER,
-            "SeismicVibrator" /*+ (tileEntity.isActive ? "On" : "")*/ + ".png"
+            ResourceType.RENDER, model.getTextureNameForState(tileEntity.isActive)
         ));
 
         switch (tileEntity.facing) {

src/main/java/mekanism/generators/client/BlockRenderingHandler.java

@@ -3,9 +3,18 @@ package mekanism.generators.client;
 import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelOnOff;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelAdvancedSolarGenerator;
+import mekanism.generators.client.model.LegacyModelBioGenerator;
+import mekanism.generators.client.model.LegacyModelGasGenerator;
+import mekanism.generators.client.model.LegacyModelHeatGenerator;
+import mekanism.generators.client.model.LegacyModelSolarGenerator;
+import mekanism.generators.client.model.LegacyModelWindGenerator;
 import mekanism.generators.client.model.ModelAdvancedSolarGenerator;
 import mekanism.generators.client.model.ModelBioGenerator;
 import mekanism.generators.client.model.ModelGasGenerator;
@@ -24,13 +33,25 @@ import org.lwjgl.opengl.GL11;
 public class BlockRenderingHandler implements ISimpleBlockRenderingHandler {
     private Minecraft mc = Minecraft.getMinecraft();
 
-    public ModelAdvancedSolarGenerator advancedSolarGenerator
-        = new ModelAdvancedSolarGenerator();
-    public ModelSolarGenerator solarGenerator = new ModelSolarGenerator();
-    public ModelBioGenerator bioGenerator = new ModelBioGenerator();
-    public ModelHeatGenerator heatGenerator = new ModelHeatGenerator();
-    public ModelGasGenerator gasGenerator = new ModelGasGenerator();
-    public ModelWindGenerator windGenerator = new ModelWindGenerator();
+    public ModelMekanismBase advancedSolarGenerator
+        = MekanismConfig.client.modelType.createModel(
+            ModelAdvancedSolarGenerator::new, LegacyModelAdvancedSolarGenerator::new
+        );
+    public ModelMekanismBase solarGenerator = MekanismConfig.client.modelType.createModel(
+        ModelSolarGenerator::new, LegacyModelSolarGenerator::new
+    );
+    public ModelMekanismBase bioGenerator = MekanismConfig.client.modelType.createModel(
+        ModelBioGenerator::new, LegacyModelBioGenerator::new
+    );
+    public IModelOnOff heatGenerator = MekanismConfig.client.modelType.createModel(
+        ModelHeatGenerator::new, LegacyModelHeatGenerator::new
+    );
+    public ModelMekanismBase gasGenerator = MekanismConfig.client.modelType.createModel(
+        ModelGasGenerator::new, LegacyModelGasGenerator::new
+    );
+    public ModelMekanismBase windGenerator = MekanismConfig.client.modelType.createModel(
+        ModelWindGenerator::new, LegacyModelWindGenerator::new
+    );
 
     @Override
     public void
@@ -42,50 +63,50 @@ public class BlockRenderingHandler implements ISimpleBlockRenderingHandler {
             if (metadata == GeneratorType.BIO_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
                 GL11.glTranslated(0.0F, -1.0F, 0.0F);
-                mc.renderEngine.bindTexture(
-                    MekanismUtils.getResource(ResourceType.RENDER, "BioGenerator.png")
-                );
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, bioGenerator.getTextureName()
+                ));
                 bioGenerator.render(0.0625F);
             } else if (metadata == GeneratorType.ADVANCED_SOLAR_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
                 GL11.glRotatef(90F, 0.0F, 1.0F, 0.0F);
                 GL11.glTranslatef(0.0F, 0.2F, 0.0F);
                 mc.renderEngine.bindTexture(MekanismUtils.getResource(
-                    ResourceType.RENDER, "AdvancedSolarGenerator.png"
+                    ResourceType.RENDER, advancedSolarGenerator.getTextureName()
                 ));
                 advancedSolarGenerator.render(0.022F);
             } else if (metadata == GeneratorType.SOLAR_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
                 GL11.glRotatef(90F, 0.0F, -1.0F, 0.0F);
                 GL11.glTranslated(0.0F, -1.0F, 0.0F);
-                mc.renderEngine.bindTexture(
-                    MekanismUtils.getResource(ResourceType.RENDER, "SolarGenerator.png")
-                );
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, solarGenerator.getTextureName()
+                ));
                 solarGenerator.render(0.0625F);
             } else if (metadata == GeneratorType.HEAT_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
                 GL11.glTranslated(0.0F, -1.0F, 0.0F);
-                mc.renderEngine.bindTexture(
-                    MekanismUtils.getResource(ResourceType.RENDER, "HeatGenerator.png")
-                );
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, heatGenerator.getTextureName()
+                ));
                 heatGenerator.render(0.0625F, false, mc.renderEngine);
             } else if (metadata == GeneratorType.GAS_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 1.0F, 1.0F);
                 GL11.glRotatef(90F, -1.0F, 0.0F, 0.0F);
                 GL11.glTranslated(0.0F, -1.0F, 0.0F);
                 GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
-                mc.renderEngine.bindTexture(
-                    MekanismUtils.getResource(ResourceType.RENDER, "GasGenerator.png")
-                );
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, gasGenerator.getTextureName()
+                ));
                 gasGenerator.render(0.0625F);
             } else if (metadata == GeneratorType.WIND_GENERATOR.meta) {
                 GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
                 GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
                 GL11.glTranslatef(0.0F, 0.4F, 0.0F);
-                mc.renderEngine.bindTexture(
-                    MekanismUtils.getResource(ResourceType.RENDER, "WindGenerator.png")
-                );
-                windGenerator.render(0.016F, 0);
+                mc.renderEngine.bindTexture(MekanismUtils.getResource(
+                    ResourceType.RENDER, windGenerator.getTextureName()
+                ));
+                windGenerator.render(0.016F);
             } else if (metadata != 2) {
                 MekanismRenderer.renderItem(renderer, metadata, block);
             }

src/main/java/mekanism/generators/client/model/IModelWindGenerator.java

@@ -0,0 +1,7 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.IModelMekanism;
+
+public interface IModelWindGenerator extends IModelMekanism {
+    public void render(float size, double angle);
+}

src/main/java/mekanism/generators/client/model/LegacyModelAdvancedSolarGenerator.java

@@ -0,0 +1,306 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.render.MekanismRenderer;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelAdvancedSolarGenerator extends ModelMekanismBase {
+    ModelRenderer foot1;
+    ModelRenderer foot2;
+    ModelRenderer foot3;
+    ModelRenderer foot1side;
+    ModelRenderer foot2side;
+    ModelRenderer foot3side;
+    ModelRenderer smallfoot;
+    ModelRenderer base;
+    ModelRenderer outputbox;
+    ModelRenderer outputboxbottom;
+    ModelRenderer basebeam;
+    ModelRenderer connectorbox;
+    ModelRenderer panelpivotbar;
+    ModelRenderer bar1;
+    ModelRenderer bar2;
+    ModelRenderer bar3;
+    ModelRenderer bar4;
+    ModelRenderer Panel1;
+    ModelRenderer Panel2;
+    ModelRenderer Panel3;
+    ModelRenderer Panel4;
+    ModelRenderer Panel5;
+    ModelRenderer Panel6;
+    ModelRenderer Panel7;
+    ModelRenderer Panel8;
+    ModelRenderer Panel9;
+    ModelRenderer Panel10;
+    ModelRenderer Panel11;
+    ModelRenderer Panel12;
+    ModelRenderer Inputlight;
+    ModelRenderer light1;
+    ModelRenderer light2;
+    ModelRenderer light3;
+    ModelRenderer light4;
+
+    public LegacyModelAdvancedSolarGenerator() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        foot1 = new ModelRenderer(this, 16, 30);
+        foot1.addBox(16F, 13F, -2F, 6, 1, 4);
+        foot1.setRotationPoint(0F, 0F, 0F);
+        foot1.setTextureSize(128, 64);
+        foot1.mirror = true;
+        setRotation(foot1, 0F, 0F, 0.7330383F);
+        foot1.mirror = false;
+        foot2 = new ModelRenderer(this, 16, 23);
+        foot2.addBox(-2F, 13F, -22F, 4, 1, 6);
+        foot2.setRotationPoint(0F, 0F, 0F);
+        foot2.setTextureSize(128, 64);
+        foot2.mirror = true;
+        setRotation(foot2, 0.7330383F, 0F, 0F);
+        foot3 = new ModelRenderer(this, 16, 30);
+        foot3.addBox(-22F, 13F, -2F, 6, 1, 4);
+        foot3.setRotationPoint(0F, 0F, 0F);
+        foot3.setTextureSize(128, 64);
+        foot3.mirror = true;
+        setRotation(foot3, 0F, 0F, -0.7330383F);
+        foot1side = new ModelRenderer(this, 16, 35);
+        foot1side.addBox(4F, 14F, -2F, 1, 8, 4);
+        foot1side.setRotationPoint(0F, 0F, 0F);
+        foot1side.setTextureSize(128, 64);
+        foot1side.mirror = true;
+        setRotation(foot1side, 0F, 0F, 0F);
+        foot1side.mirror = false;
+        foot2side = new ModelRenderer(this, 0, 47);
+        foot2side.addBox(-2F, 9F, -5F, 4, 13, 3);
+        foot2side.setRotationPoint(0F, 0F, 0F);
+        foot2side.setTextureSize(128, 64);
+        foot2side.mirror = true;
+        setRotation(foot2side, 0F, 0F, 0F);
+        foot3side = new ModelRenderer(this, 26, 35);
+        foot3side.addBox(-4.866667F, 12F, -2F, 1, 8, 4);
+        foot3side.setRotationPoint(0F, 2F, 0F);
+        foot3side.setTextureSize(128, 64);
+        foot3side.mirror = true;
+        setRotation(foot3side, 0F, 0F, 0F);
+        smallfoot = new ModelRenderer(this, 38, 32);
+        smallfoot.addBox(-0.5F, 21F, 5F, 1, 3, 1);
+        smallfoot.setRotationPoint(0F, 0F, 0F);
+        smallfoot.setTextureSize(128, 64);
+        smallfoot.mirror = true;
+        setRotation(smallfoot, 0F, 0F, 0F);
+        base = new ModelRenderer(this, 61, 42);
+        base.addBox(-4F, 10F, -4F, 8, 13, 8);
+        base.setRotationPoint(0F, 0F, 0F);
+        base.setTextureSize(128, 64);
+        base.mirror = true;
+        setRotation(base, 0F, 0F, 0F);
+        outputbox = new ModelRenderer(this, 36, 36);
+        outputbox.addBox(-4F, 16F, 4F, 8, 8, 4);
+        outputbox.setRotationPoint(0F, -4F, 0F);
+        outputbox.setTextureSize(128, 64);
+        outputbox.mirror = true;
+        setRotation(outputbox, 0F, 0F, 0F);
+        outputboxbottom = new ModelRenderer(this, 42, 31);
+        outputboxbottom.addBox(-2F, 20F, 4F, 4, 1, 4);
+        outputboxbottom.setRotationPoint(0F, 0F, 0F);
+        outputboxbottom.setTextureSize(128, 64);
+        outputboxbottom.mirror = true;
+        setRotation(outputboxbottom, 0F, 0F, 0F);
+        basebeam = new ModelRenderer(this, 0, 14);
+        basebeam.addBox(-2F, -19F, -2F, 4, 29, 4);
+        basebeam.setRotationPoint(0F, 0F, 0F);
+        basebeam.setTextureSize(128, 64);
+        basebeam.mirror = true;
+        setRotation(basebeam, 0F, 0F, 0F);
+        connectorbox = new ModelRenderer(this, 14, 47);
+        connectorbox.addBox(-2.5F, -21F, -2.5F, 5, 3, 5);
+        connectorbox.setRotationPoint(0F, 0F, 0F);
+        connectorbox.setTextureSize(128, 64);
+        connectorbox.mirror = true;
+        setRotation(connectorbox, 0F, 0F, 0F);
+        panelpivotbar = new ModelRenderer(this, 0, 0);
+        panelpivotbar.addBox(-15F, -20.5F, -0.5F, 30, 2, 1);
+        panelpivotbar.setRotationPoint(0F, 0F, 0F);
+        panelpivotbar.setTextureSize(128, 64);
+        panelpivotbar.mirror = true;
+        setRotation(panelpivotbar, 0F, 0F, 0F);
+        bar1 = new ModelRenderer(this, 60, 30);
+        bar1.addBox(12.7F, -20.5F, -16F, 1, 1, 33);
+        bar1.setRotationPoint(0F, 0F, 0F);
+        bar1.setTextureSize(128, 64);
+        bar1.mirror = true;
+        setRotation(bar1, 0F, 0F, 0F);
+        bar2 = new ModelRenderer(this, 60, 30);
+        bar2.addBox(2.6F, -20.5F, -16F, 1, 1, 33);
+        bar2.setRotationPoint(0F, 0F, 0F);
+        bar2.setTextureSize(128, 64);
+        bar2.mirror = true;
+        setRotation(bar2, 0F, 0F, 0F);
+        bar3 = new ModelRenderer(this, 60, 30);
+        bar3.addBox(-3.6F, -20.5F, -16F, 1, 1, 33);
+        bar3.setRotationPoint(0F, 0F, 0F);
+        bar3.setTextureSize(128, 64);
+        bar3.mirror = true;
+        setRotation(bar3, 0F, 0F, 0F);
+        bar4 = new ModelRenderer(this, 60, 30);
+        bar4.addBox(-13.7F, -20.5F, -16F, 1, 1, 33);
+        bar4.setRotationPoint(0F, 0F, 0F);
+        bar4.setTextureSize(128, 64);
+        bar4.mirror = true;
+        setRotation(bar4, 0F, 0F, 0F);
+        Panel1 = new ModelRenderer(this, 70, 10);
+        Panel1.addBox(13.5F, -21F, -23.8F, 10, 1, 16);
+        Panel1.setRotationPoint(0F, 0F, 0F);
+        Panel1.setTextureSize(128, 64);
+        Panel1.mirror = true;
+        setRotation(Panel1, 0F, 0F, 0F);
+        Panel2 = new ModelRenderer(this, 16, 8);
+        Panel2.addBox(13.5F, -21F, -6.5F, 10, 1, 13);
+        Panel2.setRotationPoint(0F, 0F, 0F);
+        Panel2.setTextureSize(128, 64);
+        Panel2.mirror = true;
+        setRotation(Panel2, 0F, 0F, 0F);
+        Panel3 = new ModelRenderer(this, 70, 10);
+        Panel3.addBox(13.5F, -21F, 7.8F, 10, 1, 16);
+        Panel3.setRotationPoint(0F, 0F, 0F);
+        Panel3.setTextureSize(128, 64);
+        Panel3.mirror = true;
+        setRotation(Panel3, 0F, 0F, 0F);
+        Panel4 = new ModelRenderer(this, 70, 10);
+        Panel4.addBox(3F, -21F, -23.8F, 10, 1, 16);
+        Panel4.setRotationPoint(0F, 0F, 0F);
+        Panel4.setTextureSize(128, 64);
+        Panel4.mirror = true;
+        setRotation(Panel4, 0F, 0F, 0F);
+        Panel5 = new ModelRenderer(this, 16, 8);
+        Panel5.addBox(3F, -21F, -6.5F, 10, 1, 13);
+        Panel5.setRotationPoint(0F, 0F, 0F);
+        Panel5.setTextureSize(128, 64);
+        Panel5.mirror = true;
+        setRotation(Panel5, 0F, 0F, 0F);
+        Panel6 = new ModelRenderer(this, 70, 10);
+        Panel6.addBox(3F, -21F, 7.8F, 10, 1, 16);
+        Panel6.setRotationPoint(0F, 0F, 0F);
+        Panel6.setTextureSize(128, 64);
+        Panel6.mirror = true;
+        setRotation(Panel6, 0F, 0F, 0F);
+        Panel7 = new ModelRenderer(this, 70, 10);
+        Panel7.addBox(-13F, -21F, -23.8F, 10, 1, 16);
+        Panel7.setRotationPoint(0F, 0F, 0F);
+        Panel7.setTextureSize(128, 64);
+        Panel7.mirror = true;
+        setRotation(Panel7, 0F, 0F, 0F);
+        Panel8 = new ModelRenderer(this, 16, 8);
+        Panel8.addBox(-13F, -21F, -6.5F, 10, 1, 13);
+        Panel8.setRotationPoint(0F, 0F, 0F);
+        Panel8.setTextureSize(128, 64);
+        Panel8.mirror = true;
+        setRotation(Panel8, 0F, 0F, 0F);
+        Panel9 = new ModelRenderer(this, 70, 10);
+        Panel9.addBox(-13F, -21F, 7.8F, 10, 1, 16);
+        Panel9.setRotationPoint(0F, 0F, 0F);
+        Panel9.setTextureSize(128, 64);
+        Panel9.mirror = true;
+        setRotation(Panel9, 0F, 0F, 0F);
+        Panel10 = new ModelRenderer(this, 70, 10);
+        Panel10.addBox(-23.5F, -21F, -23.8F, 10, 1, 16);
+        Panel10.setRotationPoint(0F, 0F, 0F);
+        Panel10.setTextureSize(128, 64);
+        Panel10.mirror = true;
+        setRotation(Panel10, 0F, 0F, 0F);
+        Panel11 = new ModelRenderer(this, 16, 8);
+        Panel11.addBox(-23.5F, -21F, -6.5F, 10, 1, 13);
+        Panel11.setRotationPoint(0F, 0F, 0F);
+        Panel11.setTextureSize(128, 64);
+        Panel11.mirror = true;
+        setRotation(Panel11, 0F, 0F, 0F);
+        Panel12 = new ModelRenderer(this, 70, 10);
+        Panel12.addBox(-23.5F, -21F, 7.8F, 10, 1, 16);
+        Panel12.setRotationPoint(0F, 0F, 0F);
+        Panel12.setTextureSize(128, 64);
+        Panel12.mirror = true;
+        setRotation(Panel12, 0F, 0F, 0F);
+        Inputlight = new ModelRenderer(this, 5, 6);
+        Inputlight.addBox(-1F, 15F, 7.2F, 2, 2, 1);
+        Inputlight.setRotationPoint(0F, 0F, 0F);
+        Inputlight.setTextureSize(128, 64);
+        Inputlight.mirror = true;
+        setRotation(Inputlight, 0F, 0F, 0F);
+        light1 = new ModelRenderer(this, 5, 4);
+        light1.addBox(3.2F, 15F, 6F, 1, 2, 1);
+        light1.setRotationPoint(0F, 0F, 0F);
+        light1.setTextureSize(128, 64);
+        light1.mirror = true;
+        setRotation(light1, 0F, 0F, 0F);
+        light2 = new ModelRenderer(this, 5, 4);
+        light2.addBox(-4.2F, 15F, 6F, 1, 2, 1);
+        light2.setRotationPoint(0F, 0F, 0F);
+        light2.setTextureSize(128, 64);
+        light2.mirror = true;
+        setRotation(light2, 0F, 0F, 0F);
+        light3 = new ModelRenderer(this, 5, 4);
+        light3.addBox(3.2F, 15F, 2F, 1, 2, 3);
+        light3.setRotationPoint(0F, 0F, 0F);
+        light3.setTextureSize(128, 64);
+        light3.mirror = true;
+        setRotation(light3, 0F, 0F, 0F);
+        light4 = new ModelRenderer(this, 5, 4);
+        light4.addBox(-4.2F, 15F, 2F, 1, 2, 3);
+        light4.setRotationPoint(0F, 0F, 0F);
+        light4.setTextureSize(128, 64);
+        light4.mirror = true;
+        setRotation(light4, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        foot1.render(size);
+        foot2.render(size);
+        foot3.render(size);
+        foot1side.render(size);
+        foot2side.render(size);
+        foot3side.render(size);
+        smallfoot.render(size);
+        base.render(size);
+        outputbox.render(size);
+        outputboxbottom.render(size);
+        basebeam.render(size);
+        connectorbox.render(size);
+        panelpivotbar.render(size);
+        bar1.render(size);
+        bar2.render(size);
+        bar3.render(size);
+        bar4.render(size);
+        Panel1.render(size);
+        Panel2.render(size);
+        Panel3.render(size);
+        Panel4.render(size);
+        Panel5.render(size);
+        Panel6.render(size);
+        Panel7.render(size);
+        Panel8.render(size);
+        Panel9.render(size);
+        Panel10.render(size);
+        Panel11.render(size);
+        Panel12.render(size);
+
+        MekanismRenderer.glowOn();
+        Inputlight.render(size);
+        light1.render(size);
+        light2.render(size);
+        light3.render(size);
+        light4.render(size);
+        MekanismRenderer.glowOff();
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyAdvancedSolarGenerator.png";
+    }
+}

src/main/java/mekanism/generators/client/model/LegacyModelBioGenerator.java

@@ -0,0 +1,164 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelBioGenerator extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer Pipe1;
+    ModelRenderer Pipe2;
+    ModelRenderer ContainerLid;
+    ModelRenderer ContainerRight;
+    ModelRenderer ContainerBottom;
+    ModelRenderer ContainerFront;
+    ModelRenderer ContainerBack;
+    ModelRenderer ContainerLeft;
+    ModelRenderer Decor1;
+    ModelRenderer Decor2;
+    ModelRenderer BackTop;
+    ModelRenderer FrontPanel1;
+    ModelRenderer FrontPanel2;
+    ModelRenderer LeftPanel;
+    ModelRenderer RightPanel;
+    ModelRenderer BackPanel;
+
+    public LegacyModelBioGenerator() {
+        textureWidth = 64;
+        textureHeight = 64;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(0F, 0F, 0F, 14, 1, 14);
+        Base.setRotationPoint(-7F, 23F, -7F);
+        Base.setTextureSize(64, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Pipe1 = new ModelRenderer(this, 0, 16);
+        Pipe1.addBox(0F, 0F, 0F, 2, 2, 2);
+        Pipe1.setRotationPoint(-1F, 13F, -3F);
+        Pipe1.setTextureSize(64, 64);
+        Pipe1.mirror = true;
+        setRotation(Pipe1, 0F, 0F, 0F);
+        Pipe2 = new ModelRenderer(this, 0, 21);
+        Pipe2.addBox(0F, 0F, 0F, 2, 2, 8);
+        Pipe2.setRotationPoint(-1F, 11F, -3F);
+        Pipe2.setTextureSize(64, 64);
+        Pipe2.mirror = true;
+        setRotation(Pipe2, 0F, 0F, 0F);
+        ContainerLid = new ModelRenderer(this, 0, 32);
+        ContainerLid.addBox(0F, 0F, 0F, 4, 1, 4);
+        ContainerLid.setRotationPoint(-2F, 15F, -5F);
+        ContainerLid.setTextureSize(64, 64);
+        ContainerLid.mirror = true;
+        setRotation(ContainerLid, 0F, 0F, 0F);
+        ContainerRight = new ModelRenderer(this, 0, 38);
+        ContainerRight.addBox(0F, 0F, 0F, 1, 6, 4);
+        ContainerRight.setRotationPoint(2F, 16F, -5F);
+        ContainerRight.setTextureSize(64, 64);
+        ContainerRight.mirror = true;
+        setRotation(ContainerRight, 0F, 0F, 0F);
+        ContainerBottom = new ModelRenderer(this, 0, 49);
+        ContainerBottom.addBox(0F, 0F, 0F, 6, 1, 6);
+        ContainerBottom.setRotationPoint(-3F, 22F, -6F);
+        ContainerBottom.setTextureSize(64, 64);
+        ContainerBottom.mirror = true;
+        setRotation(ContainerBottom, 0F, 0F, 0F);
+        ContainerFront = new ModelRenderer(this, 11, 41);
+        ContainerFront.addBox(0F, 0F, 0F, 6, 6, 1);
+        ContainerFront.setRotationPoint(-3F, 16F, -6F);
+        ContainerFront.setTextureSize(64, 64);
+        ContainerFront.mirror = true;
+        setRotation(ContainerFront, 0F, 0F, 0F);
+        ContainerBack = new ModelRenderer(this, 11, 41);
+        ContainerBack.addBox(0F, 0F, 0F, 6, 6, 1);
+        ContainerBack.setRotationPoint(-3F, 16F, -1F);
+        ContainerBack.setTextureSize(64, 64);
+        ContainerBack.mirror = true;
+        setRotation(ContainerBack, 0F, 0F, 0F);
+        ContainerLeft = new ModelRenderer(this, 0, 38);
+        ContainerLeft.addBox(0F, 0F, 0F, 1, 6, 4);
+        ContainerLeft.setRotationPoint(-3F, 16F, -5F);
+        ContainerLeft.setTextureSize(64, 64);
+        setRotation(ContainerLeft, 0F, 0F, 0F);
+        ContainerLeft.mirror = false;
+        Decor1 = new ModelRenderer(this, 21, 20);
+        Decor1.addBox(0F, 0F, 0F, 2, 2, 3);
+        Decor1.setRotationPoint(4.1F, 15F, 2F);
+        Decor1.setTextureSize(64, 64);
+        Decor1.mirror = true;
+        setRotation(Decor1, 0F, 0F, 0F);
+        Decor2 = new ModelRenderer(this, 21, 20);
+        Decor2.addBox(0F, 0F, 0F, 2, 2, 3);
+        Decor2.setRotationPoint(-6.1F, 15F, 2F);
+        Decor2.setTextureSize(64, 64);
+        Decor2.mirror = true;
+        setRotation(Decor2, 0F, 0F, 0F);
+        BackTop = new ModelRenderer(this, 21, 26);
+        BackTop.addBox(0F, 0F, 0F, 8, 1, 3);
+        BackTop.setRotationPoint(-4F, 10F, 5F);
+        BackTop.setTextureSize(64, 64);
+        BackTop.mirror = true;
+        setRotation(BackTop, 0F, 0F, 0F);
+        FrontPanel1 = new ModelRenderer(this, 17, 32);
+        FrontPanel1.addBox(0F, 0F, 0F, 3, 6, 2);
+        FrontPanel1.setRotationPoint(-7F, 17F, -6F);
+        FrontPanel1.setTextureSize(64, 64);
+        FrontPanel1.mirror = true;
+        setRotation(FrontPanel1, 0F, 0F, 0F);
+        FrontPanel2 = new ModelRenderer(this, 17, 32);
+        FrontPanel2.addBox(0F, 0F, 0F, 3, 6, 2);
+        FrontPanel2.setRotationPoint(4F, 17F, -6F);
+        FrontPanel2.setTextureSize(64, 64);
+        FrontPanel2.mirror = true;
+        setRotation(FrontPanel2, 0F, 0F, 0F);
+        LeftPanel = new ModelRenderer(this, 28, 31);
+        LeftPanel.addBox(0F, 0F, 0F, 3, 7, 10);
+        LeftPanel.setRotationPoint(-7F, 16F, -4F);
+        LeftPanel.setTextureSize(64, 64);
+        LeftPanel.mirror = true;
+        setRotation(LeftPanel, 0F, 0F, 0F);
+        RightPanel = new ModelRenderer(this, 28, 31);
+        RightPanel.addBox(0F, 0F, 0F, 3, 7, 10);
+        RightPanel.setRotationPoint(4F, 16F, -4F);
+        RightPanel.setTextureSize(64, 64);
+        RightPanel.mirror = true;
+        setRotation(RightPanel, 0F, 0F, 0F);
+        BackPanel = new ModelRenderer(this, 28, 49);
+        BackPanel.addBox(0F, 0F, 0F, 10, 12, 3);
+        BackPanel.setRotationPoint(-5F, 11F, 5F);
+        BackPanel.setTextureSize(64, 64);
+        BackPanel.mirror = true;
+        setRotation(BackPanel, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        Pipe1.render(size);
+        Pipe2.render(size);
+        ContainerLid.render(size);
+        ContainerRight.render(size);
+        ContainerBottom.render(size);
+        ContainerFront.render(size);
+        ContainerBack.render(size);
+        ContainerLeft.render(size);
+        Decor1.render(size);
+        Decor2.render(size);
+        BackTop.render(size);
+        FrontPanel1.render(size);
+        FrontPanel2.render(size);
+        LeftPanel.render(size);
+        RightPanel.render(size);
+        BackPanel.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyBioGenerator.png";
+    }
+}

src/main/java/mekanism/generators/client/model/LegacyModelGasGenerator.java

@@ -0,0 +1,180 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelGasGenerator extends ModelMekanismBase {
+    ModelRenderer A;
+    ModelRenderer B;
+    ModelRenderer C;
+    ModelRenderer D;
+    ModelRenderer E;
+    ModelRenderer F;
+    ModelRenderer G;
+    ModelRenderer H;
+    ModelRenderer I;
+    ModelRenderer J;
+    ModelRenderer K;
+    ModelRenderer L;
+    ModelRenderer M;
+    ModelRenderer N;
+    ModelRenderer O;
+    ModelRenderer P;
+    ModelRenderer Q;
+    ModelRenderer R;
+    ModelRenderer S;
+
+    public LegacyModelGasGenerator() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        A = new ModelRenderer(this, 0, 0);
+        A.addBox(0F, 0F, 0F, 16, 1, 16);
+        A.setRotationPoint(-8F, 23F, -8F);
+        A.setTextureSize(128, 128);
+        A.mirror = true;
+        setRotation(A, 0F, 0F, 0F);
+        B = new ModelRenderer(this, 0, 45);
+        B.addBox(0F, 0F, 0F, 16, 12, 6);
+        B.setRotationPoint(-8F, 11F, -3F);
+        B.setTextureSize(128, 128);
+        B.mirror = true;
+        setRotation(B, 0F, 0F, 0F);
+        C = new ModelRenderer(this, 0, 64);
+        C.addBox(-3F, 0F, -8F, 6, 12, 12);
+        C.setRotationPoint(0F, 11F, 0F);
+        C.setTextureSize(128, 128);
+        C.mirror = true;
+        setRotation(C, 0F, 0F, 0F);
+        D = new ModelRenderer(this, 66, 0);
+        D.addBox(-3F, 0F, 0F, 6, 10, 4);
+        D.setRotationPoint(0F, 13F, 4F);
+        D.setTextureSize(128, 128);
+        D.mirror = true;
+        setRotation(D, 0F, 0F, 0F);
+        E = new ModelRenderer(this, 0, 20);
+        E.addBox(-5F, 0F, -3F, 10, 13, 6);
+        E.setRotationPoint(0F, 10F, 0F);
+        E.setTextureSize(128, 128);
+        E.mirror = true;
+        setRotation(E, 0F, 0.5235988F, 0F);
+        F = new ModelRenderer(this, 0, 20);
+        F.addBox(-5F, 0F, -3F, 10, 13, 6);
+        F.setRotationPoint(0F, 10F, 0F);
+        F.setTextureSize(128, 128);
+        F.mirror = true;
+        setRotation(F, 0F, -0.5235988F, 0F);
+        G = new ModelRenderer(this, 34, 20);
+        G.addBox(-3F, 0F, -5F, 6, 13, 10);
+        G.setRotationPoint(0F, 10F, 0F);
+        G.setTextureSize(128, 128);
+        G.mirror = true;
+        setRotation(G, 0F, 0F, 0F);
+        H = new ModelRenderer(this, 67, 20);
+        H.addBox(-2F, 0F, -1F, 4, 2, 2);
+        H.setRotationPoint(0F, 8F, 0F);
+        H.setTextureSize(128, 128);
+        H.mirror = true;
+        setRotation(H, 0F, -0.5235988F, 0F);
+        I = new ModelRenderer(this, 67, 20);
+        I.addBox(-2F, 0F, -1F, 4, 2, 2);
+        I.setRotationPoint(0F, 8F, 0F);
+        I.setTextureSize(128, 128);
+        I.mirror = true;
+        setRotation(I, 0F, 0.5235988F, 0F);
+        J = new ModelRenderer(this, 67, 26);
+        J.addBox(-1F, 0F, -2F, 2, 2, 4);
+        J.setRotationPoint(0F, 8F, 0F);
+        J.setTextureSize(128, 128);
+        J.mirror = true;
+        setRotation(J, 0F, 0F, 0F);
+        K = new ModelRenderer(this, 88, 0);
+        K.addBox(-3F, 0F, 0F, 6, 2, 5);
+        K.setRotationPoint(0F, 10F, 4F);
+        K.setTextureSize(128, 128);
+        K.mirror = true;
+        setRotation(K, -0.6457718F, 0F, 0F);
+        L = new ModelRenderer(this, 0, 97);
+        L.addBox(0F, 0F, 0F, 4, 10, 4);
+        L.setRotationPoint(2F, 13F, -5F);
+        L.setTextureSize(128, 128);
+        L.mirror = true;
+        setRotation(L, 0F, 0.7853982F, 0F);
+        M = new ModelRenderer(this, 0, 90);
+        M.addBox(0F, 0F, 0F, 3, 1, 2);
+        M.setRotationPoint(2F, 12F, -4F);
+        M.setTextureSize(128, 128);
+        M.mirror = true;
+        setRotation(M, 0F, 0.7853982F, 0F);
+        N = new ModelRenderer(this, 0, 97);
+        N.addBox(0F, 0F, 0F, 4, 10, 4);
+        N.setRotationPoint(-8F, 13F, -5F);
+        N.setTextureSize(128, 128);
+        N.mirror = true;
+        setRotation(N, 0F, 0.7853982F, 0F);
+        O = new ModelRenderer(this, 0, 90);
+        O.addBox(0F, 0F, 0F, 2, 1, 3);
+        O.setRotationPoint(-6F, 12F, -5F);
+        O.setTextureSize(128, 128);
+        O.mirror = true;
+        setRotation(O, 0F, 0.7853982F, 0F);
+        P = new ModelRenderer(this, 0, 118);
+        P.addBox(-5F, 0F, 0F, 10, 1, 1);
+        P.setRotationPoint(0F, 15F, -7F);
+        P.setTextureSize(128, 128);
+        P.mirror = true;
+        setRotation(P, 0F, 0F, 0F);
+        Q = new ModelRenderer(this, 0, 118);
+        Q.addBox(-5F, 0F, 0F, 10, 1, 1);
+        Q.setRotationPoint(0F, 19F, -7F);
+        Q.setTextureSize(128, 128);
+        Q.mirror = true;
+        setRotation(Q, 0F, 0F, 0F);
+        R = new ModelRenderer(this, 0, 112);
+        R.addBox(-7F, 0F, -3F, 14, 1, 3);
+        R.setRotationPoint(0F, 15F, -2F);
+        R.setTextureSize(128, 128);
+        R.mirror = true;
+        setRotation(R, 0F, 0F, 0F);
+        S = new ModelRenderer(this, 0, 112);
+        S.addBox(-7F, 0F, -3F, 14, 1, 3);
+        S.setRotationPoint(0F, 19F, -2F);
+        S.setTextureSize(128, 128);
+        S.mirror = true;
+        setRotation(S, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        A.render(size);
+        B.render(size);
+        C.render(size);
+        D.render(size);
+        E.render(size);
+        F.render(size);
+        G.render(size);
+        H.render(size);
+        I.render(size);
+        J.render(size);
+        K.render(size);
+        L.render(size);
+        M.render(size);
+        N.render(size);
+        O.render(size);
+        P.render(size);
+        Q.render(size);
+        R.render(size);
+        S.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyGasGenerator.png";
+    }
+}

src/main/java/mekanism/generators/client/model/LegacyModelHeatGenerator.java

@@ -0,0 +1,161 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelOnOff;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.renderer.texture.TextureManager;
+
+public class LegacyModelHeatGenerator
+    extends ModelMekanismBase implements IModelOnOff {
+    ModelRenderer A;
+    ModelRenderer B;
+    ModelRenderer C;
+    ModelRenderer D;
+    ModelRenderer E;
+    ModelRenderer F;
+    ModelRenderer G;
+    ModelRenderer H;
+    ModelRenderer I;
+    ModelRenderer J;
+    ModelRenderer K;
+    ModelRenderer L;
+    ModelRenderer M;
+    ModelRenderer N;
+    ModelRenderer O;
+
+    public LegacyModelHeatGenerator() {
+        textureWidth = 128;
+        textureHeight = 128;
+
+        A = new ModelRenderer(this, 0, 0);
+        A.addBox(-8F, 0F, -8F, 16, 1, 16);
+        A.setRotationPoint(0F, 23F, 0F);
+        A.setTextureSize(128, 128);
+        A.mirror = true;
+        setRotation(A, 0F, 0F, 0F);
+        B = new ModelRenderer(this, 0, 85);
+        B.addBox(0F, 0F, 0F, 8, 6, 10);
+        B.setRotationPoint(-8F, 17F, -5F);
+        B.setTextureSize(128, 128);
+        B.mirror = true;
+        setRotation(B, 0F, 0F, 0F);
+        C = new ModelRenderer(this, 0, 67);
+        C.addBox(-1F, -2F, 0F, 2, 4, 12);
+        C.setRotationPoint(-5F, 20F, -6F);
+        C.setTextureSize(128, 128);
+        C.mirror = true;
+        setRotation(C, 0F, 0F, 1.570796F);
+        D = new ModelRenderer(this, 0, 67);
+        D.addBox(-1F, -2F, 0F, 2, 4, 12);
+        D.setRotationPoint(-5F, 20F, -6F);
+        D.setTextureSize(128, 128);
+        D.mirror = true;
+        setRotation(D, 0F, 0F, 0.5235988F);
+        E = new ModelRenderer(this, 0, 67);
+        E.addBox(-1F, -2F, 0F, 2, 4, 12);
+        E.setRotationPoint(-5F, 20F, -6F);
+        E.setTextureSize(128, 128);
+        E.mirror = true;
+        setRotation(E, 0F, 0F, -0.5235988F);
+        F = new ModelRenderer(this, 68, 0);
+        F.addBox(-2F, -4F, 0F, 4, 8, 10);
+        F.setRotationPoint(-4F, 13F, -5F);
+        F.setTextureSize(128, 128);
+        F.mirror = true;
+        setRotation(F, 0F, 0F, 0.5235988F);
+        G = new ModelRenderer(this, 68, 0);
+        G.addBox(-2F, -4F, 0F, 4, 8, 10);
+        G.setRotationPoint(-4F, 13F, -5F);
+        G.setTextureSize(128, 128);
+        G.mirror = true;
+        setRotation(G, 0F, 0F, -0.5235988F);
+        H = new ModelRenderer(this, 68, 0);
+        H.addBox(-2F, -4F, 0F, 4, 8, 10);
+        H.setRotationPoint(-4F, 13F, -5F);
+        H.setTextureSize(128, 128);
+        H.mirror = true;
+        setRotation(H, 0F, 0F, 1.570796F);
+        I = new ModelRenderer(this, 0, 18);
+        I.addBox(0F, 0F, 0F, 8, 13, 14);
+        I.setRotationPoint(0F, 10F, -6F);
+        I.setTextureSize(128, 128);
+        I.mirror = true;
+        setRotation(I, 0F, 0F, 0F);
+        J = new ModelRenderer(this, 0, 47);
+        J.addBox(0F, 0F, 0F, 6, 11, 1);
+        J.setRotationPoint(1F, 11F, -7F);
+        J.setTextureSize(128, 128);
+        J.mirror = true;
+        setRotation(J, 0F, 0F, 0F);
+        K = new ModelRenderer(this, 51, 21);
+        K.addBox(0F, 0F, 0F, 10, 4, 1);
+        K.setRotationPoint(-8F, 13F, -4F);
+        K.setTextureSize(128, 128);
+        K.mirror = true;
+        setRotation(K, 0F, 0F, 0F);
+        L = new ModelRenderer(this, 51, 21);
+        L.addBox(0F, 0F, 0F, 10, 4, 1);
+        L.setRotationPoint(-8F, 13F, 3F);
+        L.setTextureSize(128, 128);
+        L.mirror = true;
+        setRotation(L, 0F, 0F, 0F);
+        M = new ModelRenderer(this, 0, 103);
+        M.addBox(0F, 0F, 0F, 2, 4, 2);
+        M.setRotationPoint(-2F, 19F, -7F);
+        M.setTextureSize(128, 128);
+        M.mirror = true;
+        setRotation(M, 0F, 0F, 0F);
+        N = new ModelRenderer(this, 51, 0);
+        N.addBox(0F, 0F, 0F, 6, 1, 1);
+        N.setRotationPoint(-3F, 9F, 0F);
+        N.setTextureSize(128, 128);
+        N.mirror = true;
+        setRotation(N, 0F, 0F, 0F);
+        O = new ModelRenderer(this, 51, 0);
+        O.addBox(0F, 0F, 0F, 6, 1, 1);
+        O.setRotationPoint(-3F, 9F, 2F);
+        O.setTextureSize(128, 128);
+        O.mirror = true;
+        setRotation(O, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        A.render(size);
+        B.render(size);
+        C.render(size);
+        D.render(size);
+        E.render(size);
+        F.render(size);
+        G.render(size);
+        H.render(size);
+        I.render(size);
+        J.render(size);
+        K.render(size);
+        L.render(size);
+        M.render(size);
+        N.render(size);
+        O.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public void render(float size, boolean on, TextureManager manager) {
+        this.render(size);
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyHeatGenerator.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return on ? "LegacyHeatGeneratorOn.png" : this.getTextureName();
+    }
+}

src/main/java/mekanism/generators/client/model/LegacyModelSolarGenerator.java

@@ -0,0 +1,60 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelSolarGenerator extends ModelMekanismBase {
+    ModelRenderer Base;
+    ModelRenderer Base2;
+    ModelRenderer Stand;
+    ModelRenderer PhotovoltaicCells;
+
+    public LegacyModelSolarGenerator() {
+        textureWidth = 64;
+        textureHeight = 32;
+
+        Base = new ModelRenderer(this, 0, 16);
+        Base.addBox(0F, 0F, 0F, 6, 1, 6);
+        Base.setRotationPoint(-3F, 23F, -3F);
+        Base.setTextureSize(64, 32);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        Base2 = new ModelRenderer(this, 0, 24);
+        Base2.addBox(0F, 0F, 0F, 3, 1, 3);
+        Base2.setRotationPoint(-1.5F, 22F, -1.5F);
+        Base2.setTextureSize(64, 32);
+        Base2.mirror = true;
+        setRotation(Base2, 0F, 0F, 0F);
+        Stand = new ModelRenderer(this, 25, 16);
+        Stand.addBox(0F, 0F, 0F, 1, 7, 1);
+        Stand.setRotationPoint(-0.5F, 15F, -0.5F);
+        Stand.setTextureSize(64, 32);
+        Stand.mirror = true;
+        setRotation(Stand, 0F, 0F, 0F);
+        PhotovoltaicCells = new ModelRenderer(this, 0, 0);
+        PhotovoltaicCells.addBox(-7F, -1F, -7F, 14, 1, 14);
+        PhotovoltaicCells.setRotationPoint(0F, 15F, 0F);
+        PhotovoltaicCells.setTextureSize(64, 32);
+        PhotovoltaicCells.mirror = true;
+        setRotation(PhotovoltaicCells, 0F, 0F, 0F);
+    }
+
+    @Override
+    public void render(float size) {
+        Base.render(size);
+        Base2.render(size);
+        Stand.render(size);
+        PhotovoltaicCells.render(size);
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacySolarGenerator.png";
+    }
+}

src/main/java/mekanism/generators/client/model/LegacyModelWindGenerator.java

@@ -0,0 +1,157 @@
+package mekanism.generators.client.model;
+
+import mekanism.client.ModelMekanismBase;
+import net.minecraft.client.model.ModelRenderer;
+
+public class LegacyModelWindGenerator
+    extends ModelMekanismBase implements IModelWindGenerator {
+    ModelRenderer Base;
+    ModelRenderer TowerFront;
+    ModelRenderer TowerLeft;
+    ModelRenderer TowerBack;
+    ModelRenderer TowerRight;
+    ModelRenderer TowerMoterFront;
+    ModelRenderer TowerBaseMotor;
+    ModelRenderer TowerBaseMotorBack;
+    ModelRenderer TowerMotor;
+    ModelRenderer Rotor;
+    ModelRenderer RotorCover;
+    ModelRenderer BladeBaseC;
+    ModelRenderer BladeBaseB;
+    ModelRenderer BladeBaseA;
+
+    public LegacyModelWindGenerator() {
+        textureWidth = 128;
+        textureHeight = 64;
+
+        Base = new ModelRenderer(this, 0, 0);
+        Base.addBox(-8F, 0F, -8F, 16, 6, 16);
+        Base.setRotationPoint(0F, 18F, 0F);
+        Base.setTextureSize(128, 64);
+        Base.mirror = true;
+        setRotation(Base, 0F, 0F, 0F);
+        TowerFront = new ModelRenderer(this, 104, 0);
+        TowerFront.addBox(-5F, -62F, -7F, 10, 63, 2);
+        TowerFront.setRotationPoint(0F, 19F, 0F);
+        TowerFront.setTextureSize(128, 64);
+        TowerFront.mirror = true;
+        setRotation(TowerFront, -0.0872665F, 0F, 0F);
+        TowerLeft = new ModelRenderer(this, 104, 0);
+        TowerLeft.addBox(-5F, -62F, 5F, 10, 63, 2);
+        TowerLeft.setRotationPoint(0F, 19F, 0F);
+        TowerLeft.setTextureSize(128, 64);
+        TowerLeft.mirror = true;
+        setRotation(TowerLeft, 0.0872665F, 1.570796F, 0F);
+        TowerBack = new ModelRenderer(this, 104, 0);
+        TowerBack.addBox(-5F, -62F, 5F, 10, 63, 2);
+        TowerBack.setRotationPoint(0F, 19F, 0F);
+        TowerBack.setTextureSize(128, 64);
+        TowerBack.mirror = true;
+        setRotation(TowerBack, 0.0872665F, 0F, 0F);
+        TowerRight = new ModelRenderer(this, 104, 0);
+        TowerRight.addBox(-5F, -62F, 5F, 10, 63, 2);
+        TowerRight.setRotationPoint(0F, 19F, 0F);
+        TowerRight.setTextureSize(128, 64);
+        TowerRight.mirror = true;
+        setRotation(TowerRight, 0.0872665F, -1.570796F, 0F);
+        TowerMoterFront = new ModelRenderer(this, 40, 38);
+        TowerMoterFront.addBox(-6F, -7.3F, -5F, 12, 9, 6);
+        TowerMoterFront.setRotationPoint(0F, -45F, -1F);
+        TowerMoterFront.setTextureSize(128, 64);
+        TowerMoterFront.mirror = true;
+        setRotation(TowerMoterFront, 0F, 0F, 0F);
+        TowerBaseMotor = new ModelRenderer(this, 65, 0);
+        TowerBaseMotor.addBox(-6F, -0.3F, 0F, 12, 2, 7);
+        TowerBaseMotor.setRotationPoint(0F, -45F, 0F);
+        TowerBaseMotor.setTextureSize(128, 64);
+        TowerBaseMotor.mirror = true;
+        setRotation(TowerBaseMotor, 0F, 0F, 0F);
+        TowerBaseMotorBack = new ModelRenderer(this, 65, 30);
+        TowerBaseMotorBack.addBox(-4F, -3.3F, 7F, 8, 4, 3);
+        TowerBaseMotorBack.setRotationPoint(0F, -45F, 0F);
+        TowerBaseMotorBack.setTextureSize(128, 64);
+        TowerBaseMotorBack.mirror = true;
+        setRotation(TowerBaseMotorBack, 0F, 0F, 0F);
+        TowerMotor = new ModelRenderer(this, 65, 15);
+        TowerMotor.addBox(-4F, -6.3F, 0F, 8, 6, 7);
+        TowerMotor.setRotationPoint(0F, -45F, 0F);
+        TowerMotor.setTextureSize(128, 64);
+        TowerMotor.mirror = true;
+        setRotation(TowerMotor, 0F, 0F, 0F);
+        Rotor = new ModelRenderer(this, 88, 30);
+        Rotor.addBox(-0.5F, -0.5F, 0F, 1, 1, 3);
+        Rotor.setRotationPoint(0F, -48F, -8F);
+        Rotor.setTextureSize(128, 64);
+        Rotor.mirror = true;
+        setRotation(Rotor, 0F, 0F, 0F);
+        RotorCover = new ModelRenderer(this, 88, 35);
+        RotorCover.addBox(-2F, -2F, -1F, 4, 4, 1);
+        RotorCover.setRotationPoint(0F, -48F, -8F);
+        RotorCover.setTextureSize(128, 64);
+        RotorCover.mirror = true;
+        setRotation(RotorCover, 0F, 0F, 0F);
+        BladeBaseC = new ModelRenderer(this, 0, 54);
+        BladeBaseC.addBox(1F, -1F, 0F, 32, 2, 1);
+        BladeBaseC.setRotationPoint(0F, -48F, -8F);
+        BladeBaseC.setTextureSize(128, 64);
+        BladeBaseC.mirror = true;
+        setRotation(BladeBaseC, 0F, 0F, getRotation(120));
+        BladeBaseB = new ModelRenderer(this, 0, 54);
+        BladeBaseB.addBox(1F, -1F, 0F, 32, 2, 1);
+        BladeBaseB.setRotationPoint(0F, -48F, -8F);
+        BladeBaseB.setTextureSize(128, 64);
+        BladeBaseB.mirror = true;
+        setRotation(BladeBaseB, 0F, 0F, 0F);
+        BladeBaseA = new ModelRenderer(this, 0, 54);
+        BladeBaseA.addBox(1F, -1F, 0F, 32, 2, 1);
+        BladeBaseA.setRotationPoint(0F, -48F, -8F);
+        BladeBaseA.setTextureSize(128, 64);
+        BladeBaseA.mirror = true;
+        setRotation(BladeBaseA, 0F, 0F, getRotation(240));
+    }
+
+    @Override
+    public void render(float size, double angle) {
+        Base.render(size);
+        TowerFront.render(size);
+        TowerLeft.render(size);
+        TowerBack.render(size);
+        TowerRight.render(size);
+        TowerMoterFront.render(size);
+        TowerBaseMotor.render(size);
+        TowerBaseMotorBack.render(size);
+        TowerMotor.render(size);
+        Rotor.render(size);
+        RotorCover.render(size);
+        setRotation(BladeBaseC, 0.0F, 0.0F, getRotation(getAbsoluteAngle(120 + angle)));
+        BladeBaseC.render(size);
+        setRotation(BladeBaseB, 0.0F, 0.0F, getRotation(getAbsoluteAngle(angle)));
+        BladeBaseB.render(size);
+        setRotation(BladeBaseA, 0.0F, 0.0F, getRotation(getAbsoluteAngle(240 + angle)));
+        BladeBaseA.render(size);
+    }
+
+    public float getRotation(double angle) {
+        return ((float) angle / (float) 180) * (float) Math.PI;
+    }
+
+    public double getAbsoluteAngle(double angle) {
+        return angle % 360;
+    }
+
+    private void setRotation(ModelRenderer model, float x, float y, float z) {
+        model.rotateAngleX = x;
+        model.rotateAngleY = y;
+        model.rotateAngleZ = z;
+    }
+
+    @Override
+    public void render(float size) {
+        this.render(size, 0);
+    }
+
+    @Override
+    public String getTextureName() {
+        return "LegacyWindGenerator.png";
+    }
+}

src/main/java/mekanism/generators/client/model/ModelAdvancedSolarGenerator.java

@@ -2,11 +2,11 @@ package mekanism.generators.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelAdvancedSolarGenerator extends ModelBase {
+public class ModelAdvancedSolarGenerator extends ModelMekanismBase {
     ModelRenderer Shape1;
     ModelRenderer Shape2;
     ModelRenderer Shape3;
@@ -126,6 +126,7 @@ public class ModelAdvancedSolarGenerator extends ModelBase {
         setRotation(Shape16, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         Shape1.render(size);
         Shape2.render(size);
@@ -150,4 +151,9 @@ public class ModelAdvancedSolarGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "AdvancedSolarGenerator.png";
+    }
 }

src/main/java/mekanism/generators/client/model/ModelBioGenerator.java

@@ -1,10 +1,10 @@
 package mekanism.generators.client.model;
 
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
-import net.minecraft.client.model.ModelBase;
 import net.minecraft.client.model.ModelRenderer;
 
-public class ModelBioGenerator extends ModelBase {
+public class ModelBioGenerator extends ModelMekanismBase{
     ModelRenderer base;
     ModelRenderer sideRight;
     ModelRenderer back;
@@ -54,6 +54,7 @@ public class ModelBioGenerator extends ModelBase {
         setRotation(sideLeft, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         base.render(size);
         sideRight.render(size);
@@ -71,4 +72,9 @@ public class ModelBioGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "BioGenerator.png";
+    }
 }

src/main/java/mekanism/generators/client/model/ModelGasGenerator.java

@@ -2,11 +2,11 @@ package mekanism.generators.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
 @SideOnly(Side.CLIENT)
-public class ModelGasGenerator extends ModelBase {
+public class ModelGasGenerator extends ModelMekanismBase {
     ModelRenderer port4;
     ModelRenderer baseStand;
     ModelRenderer pillar4;
@@ -147,6 +147,7 @@ public class ModelGasGenerator extends ModelBase {
         setRotation(connector1, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         port4.render(size);
         baseStand.render(size);
@@ -174,4 +175,9 @@ public class ModelGasGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "GasGenerator.png";
+    }
 }

src/main/java/mekanism/generators/client/model/ModelHeatGenerator.java

@@ -2,17 +2,18 @@ package mekanism.generators.client.model;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.client.ModelMekanismBase;
+import mekanism.client.model.IModelOnOff;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
-import net.minecraft.client.model.ModelBase;
 import net.minecraft.client.model.ModelRenderer;
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.util.ResourceLocation;
 import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
-public class ModelHeatGenerator extends ModelBase {
+public class ModelHeatGenerator extends ModelMekanismBase implements IModelOnOff {
     public static ResourceLocation OVERLAY_ON
         = MekanismUtils.getResource(ResourceType.RENDER, "HeatGenerator_OverlayOn.png");
     public static ResourceLocation OVERLAY_OFF
@@ -140,25 +141,27 @@ public class ModelHeatGenerator extends ModelBase {
         setRotation(base, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size, boolean on, TextureManager manager) {
         GL11.glPushMatrix();
         MekanismRenderer.blendOn();
 
-        doRender(size);
+        render(size);
 
         manager.bindTexture(on ? OVERLAY_ON : OVERLAY_OFF);
         GL11.glScalef(1.001F, 1.001F, 1.001F);
         GL11.glTranslatef(0, -0.0011F, 0);
         MekanismRenderer.glowOn();
 
-        doRender(size);
+        render(size);
 
         MekanismRenderer.glowOff();
         MekanismRenderer.blendOff();
         GL11.glPopMatrix();
     }
 
-    private void doRender(float size) {
+    @Override
+    public void render(float size) {
         drum.render(size);
         ring1.render(size);
         ring2.render(size);
@@ -182,4 +185,14 @@ public class ModelHeatGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "HeatGenerator.png";
+    }
+
+    @Override
+    public String getTextureNameForState(boolean on) {
+        return this.getTextureName();
+    }
 }

src/main/java/mekanism/generators/client/model/ModelSolarGenerator.java

@@ -1,9 +1,9 @@
 package mekanism.generators.client.model;
 
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
-public class ModelSolarGenerator extends ModelBase {
+public class ModelSolarGenerator extends ModelMekanismBase {
     ModelRenderer solarPanel;
     ModelRenderer solarPanelBottom;
     ModelRenderer solarPanelConnector;
@@ -67,6 +67,7 @@ public class ModelSolarGenerator extends ModelBase {
         setRotation(solarPanelPipeBase, 0F, 0F, 0F);
     }
 
+    @Override
     public void render(float size) {
         solarPanel.render(size);
         solarPanelBottom.render(size);
@@ -83,4 +84,9 @@ public class ModelSolarGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public String getTextureName() {
+        return "SolarGenerator.png";
+    }
 }

src/main/java/mekanism/generators/client/model/ModelWindGenerator.java

@@ -1,9 +1,9 @@
 package mekanism.generators.client.model;
 
-import net.minecraft.client.model.ModelBase;
+import mekanism.client.ModelMekanismBase;
 import net.minecraft.client.model.ModelRenderer;
 
-public class ModelWindGenerator extends ModelBase {
+public class ModelWindGenerator extends ModelMekanismBase implements IModelWindGenerator {
     ModelRenderer head;
     ModelRenderer plateConnector2;
     ModelRenderer plateConnector;
@@ -158,6 +158,7 @@ public class ModelWindGenerator extends ModelBase {
         setRotation(post1d, -0.0347321F, 0F, -0.0347321F);
     }
 
+    @Override
     public void render(float size, double angle) {
         head.render(size);
         plateConnector2.render(size);
@@ -213,4 +214,14 @@ public class ModelWindGenerator extends ModelBase {
         model.rotateAngleY = y;
         model.rotateAngleZ = z;
     }
+
+    @Override
+    public void render(float size) {
+        this.render(size, 0.0);
+    }
+
+    @Override
+    public String getTextureName() {
+        return "WindGenerator.png";
+    }
 }

src/main/java/mekanism/generators/client/render/RenderAdvancedSolarGenerator.java

@@ -2,8 +2,11 @@ package mekanism.generators.client.render;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelAdvancedSolarGenerator;
 import mekanism.generators.client.model.ModelAdvancedSolarGenerator;
 import mekanism.generators.common.tile.TileEntityAdvancedSolarGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderAdvancedSolarGenerator extends TileEntitySpecialRenderer {
-    private ModelAdvancedSolarGenerator model = new ModelAdvancedSolarGenerator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelAdvancedSolarGenerator::new, LegacyModelAdvancedSolarGenerator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -33,10 +38,10 @@ public class RenderAdvancedSolarGenerator extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
         bindTexture(
-            MekanismUtils.getResource(ResourceType.RENDER, "AdvancedSolarGenerator.png")
+            MekanismUtils.getResource(ResourceType.RENDER, this.model.getTextureName())
         );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/generators/client/render/RenderBioGenerator.java

@@ -5,11 +5,14 @@ import java.util.Map;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
 import mekanism.client.render.MekanismRenderer;
 import mekanism.client.render.MekanismRenderer.DisplayInteger;
 import mekanism.client.render.MekanismRenderer.Model3D;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelBioGenerator;
 import mekanism.generators.client.model.ModelBioGenerator;
 import mekanism.generators.common.tile.TileEntityBioGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -20,7 +23,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderBioGenerator extends TileEntitySpecialRenderer {
-    private ModelBioGenerator model = new ModelBioGenerator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelBioGenerator::new, LegacyModelBioGenerator::new
+    );
 
     private Map<ForgeDirection, DisplayInteger[]> energyDisplays
         = new HashMap<ForgeDirection, DisplayInteger[]>();
@@ -53,7 +58,9 @@ public class RenderBioGenerator extends TileEntitySpecialRenderer {
 
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "BioGenerator.png"));
+        bindTexture(
+            MekanismUtils.getResource(ResourceType.RENDER, this.model.getTextureName())
+        );
 
         switch (tileEntity.facing) {
             case 2:
@@ -90,51 +97,96 @@ public class RenderBioGenerator extends TileEntitySpecialRenderer {
         for (int i = 0; i < stages; i++) {
             displays[i] = DisplayInteger.createAndStart();
 
-            switch (side) {
-                case NORTH: {
-                    model3D.minZ = 0.5;
-                    model3D.maxZ = 0.875;
+            if (MekanismConfig.client.modelType.isOld()) {
+                switch (side) {
+                    case NORTH: {
+                        model3D.minZ = 0.5625;
+                        model3D.maxZ = 0.8125;
 
-                    model3D.minX = 0.1875;
-                    model3D.maxX = 0.8215;
-                    model3D.minY = 0.4375;
-                    model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
-                    break;
+                        model3D.minX = 0.375;
+                        model3D.maxX = 0.625;
+                        model3D.minY = 0.125;
+                        model3D.maxY = 0.125 + ((float) i / stages) * .34375;
+                        break;
+                    }
+                    case SOUTH: {
+                        model3D.minZ = 0.1875;
+                        model3D.maxZ = 0.4375;
+
+                        model3D.minX = 0.375;
+                        model3D.maxX = 0.625;
+                        model3D.minY = 0.125;
+                        model3D.maxY = 0.125 + ((float) i / stages) * .34375;
+                        break;
+                    }
+                    case WEST: {
+                        model3D.minX = 0.5625;
+                        model3D.maxX = 0.8125;
+
+                        model3D.minZ = 0.375;
+                        model3D.maxZ = 0.625;
+                        model3D.minY = 0.125;
+                        model3D.maxY = 0.125 + ((float) i / stages) * .34375;
+                        break;
+                    }
+                    case EAST: {
+                        model3D.minX = 0.1875;
+                        model3D.maxX = 0.4375;
+
+                        model3D.minZ = 0.375;
+                        model3D.maxZ = 0.625;
+                        model3D.minY = 0.125;
+                        model3D.maxY = 0.125 + ((float) i / stages) * .34375;
+                        break;
+                    }
                 }
-                case SOUTH: {
-                    model3D.minZ = 0.125;
-                    model3D.maxZ = 0.5;
+            } else {
+                switch (side) {
+                    case NORTH: {
+                        model3D.minZ = 0.5;
+                        model3D.maxZ = 0.875;
 
-                    model3D.minX = 0.1875;
-                    model3D.maxX = 0.8215;
-                    model3D.minY = 0.4375;
-                    model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
-                    break;
-                }
-                case WEST: {
-                    model3D.minX = 0.5;
-                    model3D.maxX = 0.875;
+                        model3D.minX = 0.1875;
+                        model3D.maxX = 0.8215;
+                        model3D.minY = 0.4375;
+                        model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
+                        break;
+                    }
+                    case SOUTH: {
+                        model3D.minZ = 0.125;
+                        model3D.maxZ = 0.5;
 
-                    model3D.minZ = 0.1875;
-                    model3D.maxZ = 0.8215;
-                    model3D.minY = 0.4375;
-                    model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
-                    break;
-                }
-                case EAST: {
-                    model3D.minX = 0.125;
-                    model3D.maxX = 0.5;
+                        model3D.minX = 0.1875;
+                        model3D.maxX = 0.8215;
+                        model3D.minY = 0.4375;
+                        model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
+                        break;
+                    }
+                    case WEST: {
+                        model3D.minX = 0.5;
+                        model3D.maxX = 0.875;
 
-                    model3D.minZ = 0.1875;
-                    model3D.maxZ = 0.8215;
-                    model3D.minY = 0.4375;
-                    model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
-                    break;
+                        model3D.minZ = 0.1875;
+                        model3D.maxZ = 0.8215;
+                        model3D.minY = 0.4375;
+                        model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
+                        break;
+                    }
+                    case EAST: {
+                        model3D.minX = 0.125;
+                        model3D.maxX = 0.5;
+
+                        model3D.minZ = 0.1875;
+                        model3D.maxZ = 0.8215;
+                        model3D.minY = 0.4375;
+                        model3D.maxY = 0.4375 + ((float) i / stages) * 0.4375;
+                        break;
+                    }
                 }
             }
 
             MekanismRenderer.renderObject(model3D);
-            displays[i].endList();
+            DisplayInteger.endList();
         }
 
         energyDisplays.put(side, displays);

src/main/java/mekanism/generators/client/render/RenderGasGenerator.java

@@ -2,8 +2,11 @@ package mekanism.generators.client.render;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelGasGenerator;
 import mekanism.generators.client.model.ModelGasGenerator;
 import mekanism.generators.common.tile.TileEntityGasGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderGasGenerator extends TileEntitySpecialRenderer {
-    private ModelGasGenerator model = new ModelGasGenerator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelGasGenerator::new, LegacyModelGasGenerator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -26,9 +31,11 @@ public class RenderGasGenerator extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "GasGenerator.png"));
+        bindTexture(
+            MekanismUtils.getResource(ResourceType.RENDER, this.model.getTextureName())
+        );
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(90, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/generators/client/render/RenderHeatGenerator.java

@@ -2,8 +2,11 @@ package mekanism.generators.client.render;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import mekanism.api.MekanismConfig;
+import mekanism.client.model.IModelOnOff;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelHeatGenerator;
 import mekanism.generators.client.model.ModelHeatGenerator;
 import mekanism.generators.common.tile.TileEntityHeatGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -12,7 +15,9 @@ import org.lwjgl.opengl.GL11;
 
 @SideOnly(Side.CLIENT)
 public class RenderHeatGenerator extends TileEntitySpecialRenderer {
-    private ModelHeatGenerator model = new ModelHeatGenerator();
+    private IModelOnOff model = MekanismConfig.client.modelType.createModel(
+        ModelHeatGenerator::new, LegacyModelHeatGenerator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -30,9 +35,11 @@ public class RenderHeatGenerator extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "HeatGenerator.png"));
+        bindTexture(MekanismUtils.getResource(
+            ResourceType.RENDER, this.model.getTextureNameForState(tileEntity.isActive)
+        ));
 
-        switch (tileEntity.facing) {
+        switch (MekanismConfig.client.modelType.mapFacing(tileEntity.facing)) {
             case 2:
                 GL11.glRotatef(180, 0.0F, 1.0F, 0.0F);
                 break;

src/main/java/mekanism/generators/client/render/RenderSolarGenerator.java

@@ -1,7 +1,10 @@
 package mekanism.generators.client.render;
 
+import mekanism.api.MekanismConfig;
+import mekanism.client.ModelMekanismBase;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.LegacyModelSolarGenerator;
 import mekanism.generators.client.model.ModelSolarGenerator;
 import mekanism.generators.common.tile.TileEntitySolarGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -9,7 +12,9 @@ import net.minecraft.tileentity.TileEntity;
 import org.lwjgl.opengl.GL11;
 
 public class RenderSolarGenerator extends TileEntitySpecialRenderer {
-    private ModelSolarGenerator model = new ModelSolarGenerator();
+    private ModelMekanismBase model = MekanismConfig.client.modelType.createModel(
+        ModelSolarGenerator::new, LegacyModelSolarGenerator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -28,7 +33,9 @@ public class RenderSolarGenerator extends TileEntitySpecialRenderer {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
 
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "SolarGenerator.png"));
+        bindTexture(
+            MekanismUtils.getResource(ResourceType.RENDER, this.model.getTextureName())
+        );
 
         GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
         model.render(0.0625F);

src/main/java/mekanism/generators/client/render/RenderWindGenerator.java

@@ -1,8 +1,11 @@
 package mekanism.generators.client.render;
 
+import mekanism.api.MekanismConfig;
 import mekanism.common.Mekanism;
 import mekanism.common.util.MekanismUtils;
 import mekanism.common.util.MekanismUtils.ResourceType;
+import mekanism.generators.client.model.IModelWindGenerator;
+import mekanism.generators.client.model.LegacyModelWindGenerator;
 import mekanism.generators.client.model.ModelWindGenerator;
 import mekanism.generators.common.tile.TileEntityWindGenerator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
@@ -10,7 +13,9 @@ import net.minecraft.tileentity.TileEntity;
 import org.lwjgl.opengl.GL11;
 
 public class RenderWindGenerator extends TileEntitySpecialRenderer {
-    private ModelWindGenerator model = new ModelWindGenerator();
+    private IModelWindGenerator model = MekanismConfig.client.modelType.createModel(
+        ModelWindGenerator::new, LegacyModelWindGenerator::new
+    );
 
     @Override
     public void renderTileEntityAt(
@@ -28,7 +33,9 @@ public class RenderWindGenerator extends TileEntitySpecialRenderer {
     ) {
         GL11.glPushMatrix();
         GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
-        bindTexture(MekanismUtils.getResource(ResourceType.RENDER, "WindGenerator.png"));
+        bindTexture(
+            MekanismUtils.getResource(ResourceType.RENDER, this.model.getTextureName())
+        );
 
         switch (tileEntity.facing) {
             case 2: