textures, loads of them

com/hbm/blocks/ModBlocks.java

@@ -18,12 +18,16 @@ import cpw.mods.fml.common.registry.GameRegistry;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockDirt;
 import net.minecraft.block.BlockFalling;
+import net.minecraft.block.BlockSlab;
 import net.minecraft.block.BlockStairs;
 import net.minecraft.block.material.MapColor;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.material.MaterialLiquid;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemSlab;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidRegistry;
 
@@ -183,6 +187,8 @@ public class ModBlocks {
 	public static Block broadcaster_pc;
 	public static Block geiger;
 
+	public static Block fence_metal;
+
 	public static Block mush;
 	public static Block mush_block;
 	public static Block mush_block_stem;
@@ -867,6 +873,8 @@ public class ModBlocks {
 		
 		broadcaster_pc = new PinkCloudBroadcaster(Material.rock).setBlockName("broadcaster_pc").setCreativeTab(MainRegistry.machineTab).setHardness(5.0F).setResistance(15.0F).setBlockTextureName(RefStrings.MODID + ":broadcaster_pc");
 		geiger = new GeigerCounter(Material.rock).setBlockName("geiger").setCreativeTab(MainRegistry.machineTab).setHardness(15.0F).setResistance(0.25F).setBlockTextureName(RefStrings.MODID + ":geiger");
+		
+		fence_metal = new BlockMetalFence(Material.rock).setBlockName("fence_metal").setCreativeTab(MainRegistry.machineTab).setHardness(15.0F).setResistance(0.25F).setBlockTextureName(RefStrings.MODID + ":fence_metal");
 
 		mush = new BlockMush(Material.plants).setBlockName("mush").setCreativeTab(MainRegistry.blockTab).setLightLevel(0.5F).setStepSound(Block.soundTypeGrass).setBlockTextureName(RefStrings.MODID + ":mush");
 		mush_block = new BlockMushHuge(Material.plants).setBlockName("mush_block").setLightLevel(1.0F).setStepSound(Block.soundTypeGrass).setHardness(0.2F).setBlockTextureName(RefStrings.MODID + ":mush_block_skin");
@@ -1534,6 +1542,9 @@ public class ModBlocks {
 		//Geiger Counter
 		GameRegistry.registerBlock(geiger, geiger.getUnlocalizedName());
 		
+		//Chainlink Fence
+		GameRegistry.registerBlock(fence_metal, fence_metal.getUnlocalizedName());
+		
 		//Silo Hatch
 		GameRegistry.registerBlock(seal_frame, seal_frame.getUnlocalizedName());
 		GameRegistry.registerBlock(seal_controller, seal_controller.getUnlocalizedName());

com/hbm/blocks/generic/BlockMetalFence.java

@@ -0,0 +1,111 @@
+package com.hbm.blocks.generic;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFence;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+
+public class BlockMetalFence extends BlockFence {
+	
+	public BlockMetalFence(Material p_i45406_2_) {
+		super("", p_i45406_2_);
+	}
+
+	@Override
+	public int getRenderType(){
+		return 334082;
+	}
+	
+	@Override
+	public boolean isOpaqueCube() {
+		return false;
+	}
+	
+	@Override
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister p_149651_1_)
+    {
+        this.blockIcon = p_149651_1_.registerIcon(this.getTextureName());
+    }
+    
+    public void addCollisionBoxesToList(World p_149743_1_, int p_149743_2_, int p_149743_3_, int p_149743_4_, AxisAlignedBB p_149743_5_, List p_149743_6_, Entity p_149743_7_)
+    {
+        boolean flag = this.canConnectFenceTo(p_149743_1_, p_149743_2_, p_149743_3_, p_149743_4_ - 1);
+        boolean flag1 = this.canConnectFenceTo(p_149743_1_, p_149743_2_, p_149743_3_, p_149743_4_ + 1);
+        boolean flag2 = this.canConnectFenceTo(p_149743_1_, p_149743_2_ - 1, p_149743_3_, p_149743_4_);
+        boolean flag3 = this.canConnectFenceTo(p_149743_1_, p_149743_2_ + 1, p_149743_3_, p_149743_4_);
+        float f = 0.375F;
+        float f1 = 0.625F;
+        float f2 = 0.375F;
+        float f3 = 0.625F;
+
+        if (flag)
+        {
+            f2 = 0.0F;
+        }
+
+        if (flag1)
+        {
+            f3 = 1.0F;
+        }
+
+        if (flag || flag1)
+        {
+            this.setBlockBounds(f, 0.0F, f2, f1, 1.0F, f3);
+            addCol(p_149743_1_, p_149743_2_, p_149743_3_, p_149743_4_, p_149743_5_, p_149743_6_, p_149743_7_);
+        }
+
+        f2 = 0.375F;
+        f3 = 0.625F;
+
+        if (flag2)
+        {
+            f = 0.0F;
+        }
+
+        if (flag3)
+        {
+            f1 = 1.0F;
+        }
+
+        if (flag2 || flag3 || !flag && !flag1)
+        {
+            this.setBlockBounds(f, 0.0F, f2, f1, 1.0F, f3);
+            addCol(p_149743_1_, p_149743_2_, p_149743_3_, p_149743_4_, p_149743_5_, p_149743_6_, p_149743_7_);
+        }
+
+        if (flag)
+        {
+            f2 = 0.0F;
+        }
+
+        if (flag1)
+        {
+            f3 = 1.0F;
+        }
+
+        this.setBlockBounds(f, 0.0F, f2, f1, 1.0F, f3);
+    }
+    
+    public void addCol(World p_149743_1_, int p_149743_2_, int p_149743_3_, int p_149743_4_, AxisAlignedBB p_149743_5_, List p_149743_6_, Entity p_149743_7_)
+    {
+        AxisAlignedBB axisalignedbb1 = this.getCollisionBoundingBoxFromPool(p_149743_1_, p_149743_2_, p_149743_3_, p_149743_4_);
+
+        if (axisalignedbb1 != null && p_149743_5_.intersectsWith(axisalignedbb1))
+        {
+            p_149743_6_.add(axisalignedbb1);
+        }
+    }
+
+}

com/hbm/blocks/generic/DecoTapeRecorder.java

@@ -11,7 +11,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.MathHelper;
 import net.minecraft.world.World;
 
-public class DecoTapeRecorder extends BlockContainer{
+public class DecoTapeRecorder extends BlockContainer {
 
 	public DecoTapeRecorder(Material p_i45386_1_) {
 		super(p_i45386_1_);

com/hbm/main/ClientProxy.java

@@ -58,6 +58,7 @@ public class ClientProxy extends ServerProxy
 		RenderingRegistry.registerBlockHandler(new RenderTapeBlock());
 		RenderingRegistry.registerBlockHandler(new RenderSteelBeam());
 		RenderingRegistry.registerBlockHandler(new RenderBarrel());
+		RenderingRegistry.registerBlockHandler(new RenderFence());
 
 		MinecraftForgeClient.registerItemRenderer(ModItems.assembly_template, new ItemRenderTemplate());
 		MinecraftForgeClient.registerItemRenderer(ModItems.chemistry_template, new ItemRenderTemplate());

com/hbm/main/ResourceManager.java

@@ -1,6 +1,7 @@
 package com.hbm.main;
 
 import com.hbm.lib.RefStrings;
+import com.hbm.render.util.HFRWavefrontObject;
 
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.client.model.AdvancedModelLoader;
@@ -319,7 +320,7 @@ public class ResourceManager {
 	public static final IModelCustom missileCarrier = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/missileCarrier.obj"));
 	public static final IModelCustom missileBooster = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/missileBooster.obj"));
 	public static final IModelCustom minerRocket = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/minerRocket.obj"));
-	public static final IModelCustom soyuz = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/soyuz.obj"));
+	public static final IModelCustom soyuz = new HFRWavefrontObject(new ResourceLocation(RefStrings.MODID, "models/soyuz.obj"));
 	public static final IModelCustom soyuz_launcher_legs = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/launch_table/soyuz_launcher_legs.obj"));
 	public static final IModelCustom soyuz_launcher_table = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/launch_table/soyuz_launcher_table.obj"));
 	public static final IModelCustom soyuz_launcher_tower_base = AdvancedModelLoader.loadModel(new ResourceLocation(RefStrings.MODID, "models/launch_table/soyuz_launcher_tower_base.obj"));

com/hbm/render/block/RenderFence.java

@@ -0,0 +1,92 @@
+package com.hbm.render.block;
+
+import com.hbm.blocks.ModBlocks;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFence;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.world.IBlockAccess;
+
+public class RenderFence implements ISimpleBlockRenderingHandler {
+
+	@Override
+	public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
+
+	}
+
+	@Override
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		
+		BlockFence fence = (BlockFence) ModBlocks.fence_metal;
+		
+        boolean flag = false;
+        float f = 0.375F;
+        float f1 = 0.625F;
+        renderer.setRenderBounds((double)f, 0.0D, (double)f, (double)f1, 1.0D, (double)f1);
+        renderer.renderStandardBlock(fence, x, y, z);
+        flag = true;
+        boolean flag1 = false;
+        boolean flag2 = false;
+
+        if (fence.canConnectFenceTo(world, x - 1, y, z) || fence.canConnectFenceTo(world, x + 1, y, z))
+        {
+            flag1 = true;
+        }
+
+        if (fence.canConnectFenceTo(world, x, y, z - 1) || fence.canConnectFenceTo(world, x, y, z + 1))
+        {
+            flag2 = true;
+        }
+
+        boolean flag3 = fence.canConnectFenceTo(world, x - 1, y, z);
+        boolean flag4 = fence.canConnectFenceTo(world, x + 1, y, z);
+        boolean flag5 = fence.canConnectFenceTo(world, x, y, z - 1);
+        boolean flag6 = fence.canConnectFenceTo(world, x, y, z + 1);
+
+        if (!flag1 && !flag2)
+        {
+            flag1 = true;
+        }
+
+        f = 0.4375F;
+        f1 = 0.5625F;
+        float f2 = 0.75F;
+        float f3 = 0.9375F;
+        float f4 = flag3 ? 0.0F : f;
+        float f5 = flag4 ? 1.0F : f1;
+        float f6 = flag5 ? 0.0F : f;
+        float f7 = flag6 ? 1.0F : f1;
+        renderer.field_152631_f = true;
+
+        if (flag1)
+        {
+        	renderer.setRenderBounds((double)f4, (double)0, (double)0.5, (double)f5, (double)1, (double)0.5);
+        	renderer.renderStandardBlock(fence, x, y, z);
+            flag = true;
+        }
+
+        if (flag2)
+        {
+        	renderer.setRenderBounds((double)0.5, (double)0, (double)f6, (double)0.5, (double)1, (double)f7);
+        	renderer.renderStandardBlock(fence, x, y, z);
+            flag = true;
+        }
+
+        renderer.field_152631_f = false;
+        fence.setBlockBoundsBasedOnState(world, x, y, z);
+        return flag;
+	}
+
+	@Override
+	public boolean shouldRender3DInInventory(int modelId) {
+		return false;
+	}
+
+	@Override
+	public int getRenderId() {
+		return 334082;
+	}
+
+}

com/hbm/render/misc/BeamPronter.java

@@ -0,0 +1,105 @@
+package com.hbm.render.misc;
+
+import java.util.Random;
+
+import org.lwjgl.opengl.GL11;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.Vec3;
+
+public class BeamPronter {
+	
+	public static enum EnumWaveType {
+		RANDOM,
+		SPIRAL
+	}
+	
+	public static enum EnumBeamType {
+		SOLID,
+		LINE
+	}
+	
+	public static void prontHelix(Vec3 skeleton, double x, double y, double z, EnumWaveType wave, EnumBeamType beam, int outerColor, int innerColor, int start, int segments, float size) {
+
+		GL11.glPushMatrix();
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+        GL11.glDisable(GL11.GL_LIGHTING);
+
+		if(beam == EnumBeamType.SOLID) {
+			GL11.glDisable(GL11.GL_CULL_FACE);
+			GL11.glEnable(GL11.GL_BLEND);
+			GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
+		}
+        
+		Tessellator tessellator = Tessellator.instance;
+
+		Vec3 unit = skeleton.normalize();
+		Random rand = new Random(start);
+		double length = skeleton.lengthVector();
+		double segLength = length / segments;
+		
+		float sYaw = (float)(Math.atan2(skeleton.xCoord, skeleton.zCoord));
+        float sqrt = MathHelper.sqrt_double(skeleton.xCoord * skeleton.xCoord + skeleton.zCoord * skeleton.zCoord);
+		float sPitch = (float)(Math.atan2(skeleton.yCoord, (double)sqrt));
+		
+		double lastX = x;
+		double lastY = y;
+		double lastZ = z;
+		
+		for(int i = 0; i <= segments; i++) {
+			
+			Vec3 spinner = Vec3.createVectorHelper(size, 0, 0);
+			
+			if(wave == EnumWaveType.SPIRAL) {
+				spinner.rotateAroundY((float)Math.PI * (float)start / 180F);
+				spinner.rotateAroundY((float)Math.PI * 45F / 180F * i);
+			} else if(wave == EnumWaveType.RANDOM) {
+				spinner.rotateAroundY((float)Math.PI * 2 * rand.nextFloat());
+			}
+			
+			spinner.rotateAroundX(sPitch + (float)Math.PI * 0.5F);
+			spinner.rotateAroundY(sYaw);
+
+			double pX = unit.xCoord * segLength * i + spinner.xCoord;
+			double pY = unit.yCoord * segLength * i + spinner.yCoord;
+			double pZ = unit.zCoord * segLength * i + spinner.zCoord;
+			
+			if(beam == EnumBeamType.LINE && i > 0) {
+
+	            tessellator.startDrawing(3);
+	            tessellator.setColorOpaque_I(outerColor);
+	            tessellator.addVertex(pX + x, pY + y, pZ + z);
+	            tessellator.addVertex(lastX + x, lastY + y, lastZ + z);
+	            tessellator.draw();
+			}
+			
+			if(beam == EnumBeamType.SOLID && i > 0) {
+				
+			}
+			
+			lastX = pX;
+			lastY = pY;
+			lastZ = pZ;
+		}
+		
+		if(beam == EnumBeamType.LINE) {
+
+            tessellator.startDrawing(3);
+            tessellator.setColorOpaque_I(innerColor);
+            tessellator.addVertex(x, y, z);
+            tessellator.addVertex(x + skeleton.xCoord, y + skeleton.yCoord, z + skeleton.zCoord);
+            tessellator.draw();
+		}
+
+		if(beam == EnumBeamType.SOLID) {
+			GL11.glDisable(GL11.GL_BLEND);
+			GL11.glEnable(GL11.GL_TEXTURE_2D);
+		}
+		
+        GL11.glEnable(GL11.GL_LIGHTING);
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+		GL11.glPopMatrix();
+	}
+
+}

com/hbm/render/misc/SoyuzPronter.java

@@ -20,6 +20,7 @@ public class SoyuzPronter {
 
 		GL11.glPushMatrix();
 		GL11.glEnable(GL11.GL_CULL_FACE);
+		GL11.glShadeModel(GL11.GL_SMOOTH);
 		TextureManager tex = Minecraft.getMinecraft().getTextureManager();
 
 		tex.bindTexture(ResourceManager.soyuz_engineblock);
@@ -52,6 +53,8 @@ public class SoyuzPronter {
 		tex.bindTexture(ResourceManager.soyuz_sideengines);
 		ResourceManager.soyuz.renderOnly("SideEngines");
 		
+		GL11.glShadeModel(GL11.GL_FLAT);
+		
 		GL11.glPopMatrix();
 	}
 	
@@ -59,6 +62,7 @@ public class SoyuzPronter {
 
 		GL11.glPushMatrix();
 		GL11.glEnable(GL11.GL_CULL_FACE);
+		GL11.glShadeModel(GL11.GL_SMOOTH);
 		TextureManager tex = Minecraft.getMinecraft().getTextureManager();
 		
 		tex.bindTexture(ResourceManager.soyuz_booster);
@@ -79,6 +83,8 @@ public class SoyuzPronter {
 		ResourceManager.soyuz.renderOnly("BoosterSide.002");
 		ResourceManager.soyuz.renderOnly("BoosterSide.003");
 		
+		GL11.glShadeModel(GL11.GL_FLAT);
+		
 		GL11.glPopMatrix();
 	}
 

com/hbm/render/tileentity/RendererObjTester.java

@@ -6,6 +6,9 @@ import org.lwjgl.opengl.GL11;
 
 import com.hbm.lib.RefStrings;
 import com.hbm.main.ResourceManager;
+import com.hbm.render.misc.BeamPronter;
+import com.hbm.render.misc.BeamPronter.EnumBeamType;
+import com.hbm.render.misc.BeamPronter.EnumWaveType;
 import com.hbm.render.misc.SoyuzPronter;
 import com.hbm.render.misc.TomPronter;
 import com.hbm.render.model.ModelCalBarrel;
@@ -16,6 +19,7 @@ import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.Vec3;
 import net.minecraftforge.client.model.AdvancedModelLoader;
 import net.minecraftforge.client.model.IModelCustom;
 
@@ -37,7 +41,7 @@ public class RendererObjTester extends TileEntitySpecialRenderer {
 	public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float f)
     {
         GL11.glPushMatrix();
-        GL11.glTranslated(x + 0.5D, y, z + 0.5D);
+        GL11.glTranslated(x + 0.5, y, z + 0.5);
 		/*switch(tileEntity.getBlockMetadata())
 		{
 		case 5:
@@ -113,6 +117,8 @@ public class RendererObjTester extends TileEntitySpecialRenderer {
         
         SoyuzPronter.prontSoyuz();
         //TomPronter.prontTom();
+        //BeamPronter.prontHelix(Vec3.createVectorHelper(0, 5, 0), 0.5, 0.5, 0.5, EnumWaveType.SPIRAL, EnumBeamType.LINE, 0x0000ff, 0xffff00, (int)tileEntity.getWorldObj().getTotalWorldTime() % 360 * 25, 25, 0.25F);
+        //BeamPronter.prontHelix(Vec3.createVectorHelper(0, 5, 0), 0.5, 0.5, 0.5, EnumWaveType.SPIRAL, EnumBeamType.LINE, 0x0000ff, 0xffff00, (int)tileEntity.getWorldObj().getTotalWorldTime() % 360 * 25 + 180, 25, 0.25F);
 
         GL11.glPopMatrix();
     }

com/hbm/render/util/HFRWavefrontObject.java

@@ -0,0 +1,612 @@
+package com.hbm.render.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.IModelCustom;
+import net.minecraftforge.client.model.ModelFormatException;
+import net.minecraftforge.client.model.obj.TextureCoordinate;
+import net.minecraftforge.client.model.obj.Vertex;
+
+public class HFRWavefrontObject implements IModelCustom
+{
+    private static Pattern vertexPattern = Pattern.compile("(v( (\\-){0,1}\\d+(\\.\\d+)?){3,4} *\\n)|(v( (\\-){0,1}\\d+(\\.\\d+)?){3,4} *$)");
+    private static Pattern vertexNormalPattern = Pattern.compile("(vn( (\\-){0,1}\\d+(\\.\\d+)?){3,4} *\\n)|(vn( (\\-){0,1}\\d+(\\.\\d+)?){3,4} *$)");
+    private static Pattern textureCoordinatePattern = Pattern.compile("(vt( (\\-){0,1}\\d+\\.\\d+){2,3} *\\n)|(vt( (\\-){0,1}\\d+(\\.\\d+)?){2,3} *$)");
+    private static Pattern face_V_VT_VN_Pattern = Pattern.compile("(f( \\d+/\\d+/\\d+){3,4} *\\n)|(f( \\d+/\\d+/\\d+){3,4} *$)");
+    private static Pattern face_V_VT_Pattern = Pattern.compile("(f( \\d+/\\d+){3,4} *\\n)|(f( \\d+/\\d+){3,4} *$)");
+    private static Pattern face_V_VN_Pattern = Pattern.compile("(f( \\d+//\\d+){3,4} *\\n)|(f( \\d+//\\d+){3,4} *$)");
+    private static Pattern face_V_Pattern = Pattern.compile("(f( \\d+){3,4} *\\n)|(f( \\d+){3,4} *$)");
+    private static Pattern groupObjectPattern = Pattern.compile("([go]( [\\w\\d\\.]+) *\\n)|([go]( [\\w\\d\\.]+) *$)");
+
+    private static Matcher vertexMatcher, vertexNormalMatcher, textureCoordinateMatcher;
+    private static Matcher face_V_VT_VN_Matcher, face_V_VT_Matcher, face_V_VN_Matcher, face_V_Matcher;
+    private static Matcher groupObjectMatcher;
+
+    public ArrayList<Vertex> vertices = new ArrayList<Vertex>();
+    public ArrayList<Vertex> vertexNormals = new ArrayList<Vertex>();
+    public ArrayList<TextureCoordinate> textureCoordinates = new ArrayList<TextureCoordinate>();
+    public ArrayList<S_GroupObject> groupObjects = new ArrayList<S_GroupObject>();
+    private S_GroupObject currentGroupObject;
+    private String fileName;
+
+    public HFRWavefrontObject(ResourceLocation resource) throws ModelFormatException
+    {
+        this.fileName = resource.toString();
+
+        try
+        {
+            IResource res = Minecraft.getMinecraft().getResourceManager().getResource(resource);
+            loadObjModel(res.getInputStream());
+        }
+        catch (IOException e)
+        {
+            throw new ModelFormatException("IO Exception reading model format", e);
+        }
+    }
+
+    public HFRWavefrontObject(String filename, InputStream inputStream) throws ModelFormatException
+    {
+        this.fileName = filename;
+        loadObjModel(inputStream);
+    }
+
+    private void loadObjModel(InputStream inputStream) throws ModelFormatException
+    {
+        BufferedReader reader = null;
+
+        String currentLine = null;
+        int lineCount = 0;
+
+        try
+        {
+            reader = new BufferedReader(new InputStreamReader(inputStream));
+
+            while ((currentLine = reader.readLine()) != null)
+            {
+                lineCount++;
+                currentLine = currentLine.replaceAll("\\s+", " ").trim();
+
+                if (currentLine.startsWith("#") || currentLine.length() == 0)
+                {
+                    continue;
+                }
+                else if (currentLine.startsWith("v "))
+                {
+                    Vertex vertex = parseVertex(currentLine, lineCount);
+                    if (vertex != null)
+                    {
+                        vertices.add(vertex);
+                    }
+                }
+                else if (currentLine.startsWith("vn "))
+                {
+                    Vertex vertex = parseVertexNormal(currentLine, lineCount);
+                    if (vertex != null)
+                    {
+                        vertexNormals.add(vertex);
+                    }
+                }
+                else if (currentLine.startsWith("vt "))
+                {
+                    TextureCoordinate textureCoordinate = parseTextureCoordinate(currentLine, lineCount);
+                    if (textureCoordinate != null)
+                    {
+                        textureCoordinates.add(textureCoordinate);
+                    }
+                }
+                else if (currentLine.startsWith("f "))
+                {
+
+                    if (currentGroupObject == null)
+                    {
+                        currentGroupObject = new S_GroupObject("Default");
+                    }
+
+                    S_Face face = parseFace(currentLine, lineCount);
+
+                    if (face != null)
+                    {
+                        currentGroupObject.faces.add(face);
+                    }
+                }
+                else if (currentLine.startsWith("g ") | currentLine.startsWith("o "))
+                {
+                	S_GroupObject group = parseGroupObject(currentLine, lineCount);
+
+                    if (group != null)
+                    {
+                        if (currentGroupObject != null)
+                        {
+                            groupObjects.add(currentGroupObject);
+                        }
+                    }
+
+                    currentGroupObject = group;
+                }
+            }
+
+            groupObjects.add(currentGroupObject);
+        }
+        catch (IOException e)
+        {
+            throw new ModelFormatException("IO Exception reading model format", e);
+        }
+        finally
+        {
+            try
+            {
+                reader.close();
+            }
+            catch (IOException e)
+            {
+                // hush
+            }
+
+            try
+            {
+                inputStream.close();
+            }
+            catch (IOException e)
+            {
+                // hush
+            }
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderAll()
+    {
+        Tessellator tessellator = Tessellator.instance;
+
+        if (currentGroupObject != null)
+        {
+            tessellator.startDrawing(currentGroupObject.glDrawingMode);
+        }
+        else
+        {
+            tessellator.startDrawing(GL11.GL_TRIANGLES);
+        }
+        tessellateAll(tessellator);
+
+        tessellator.draw();
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void tessellateAll(Tessellator tessellator)
+    {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            groupObject.render(tessellator);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderOnly(String... groupNames)
+    {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            for (String groupName : groupNames)
+            {
+                if (groupName.equalsIgnoreCase(groupObject.name))
+                {
+                    groupObject.render();
+                }
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void tessellateOnly(Tessellator tessellator, String... groupNames) {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            for (String groupName : groupNames)
+            {
+                if (groupName.equalsIgnoreCase(groupObject.name))
+                {
+                    groupObject.render(tessellator);
+                }
+            }
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderPart(String partName)
+    {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            if (partName.equalsIgnoreCase(groupObject.name))
+            {
+                groupObject.render();
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void tessellatePart(Tessellator tessellator, String partName) {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            if (partName.equalsIgnoreCase(groupObject.name))
+            {
+                groupObject.render(tessellator);
+            }
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderAllExcept(String... excludedGroupNames)
+    {
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            boolean skipPart=false;
+            for (String excludedGroupName : excludedGroupNames)
+            {
+                if (excludedGroupName.equalsIgnoreCase(groupObject.name))
+                {
+                    skipPart=true;
+                }
+            }
+            if(!skipPart)
+            {
+                groupObject.render();
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void tessellateAllExcept(Tessellator tessellator, String... excludedGroupNames)
+    {
+        boolean exclude;
+        for (S_GroupObject groupObject : groupObjects)
+        {
+            exclude=false;
+            for (String excludedGroupName : excludedGroupNames)
+            {
+                if (excludedGroupName.equalsIgnoreCase(groupObject.name))
+                {
+                    exclude=true;
+                }
+            }
+            if(!exclude)
+            {
+                groupObject.render(tessellator);
+            }
+        }
+    }
+
+    private Vertex parseVertex(String line, int lineCount) throws ModelFormatException
+    {
+        Vertex vertex = null;
+
+        if (isValidVertexLine(line))
+        {
+            line = line.substring(line.indexOf(" ") + 1);
+            String[] tokens = line.split(" ");
+
+            try
+            {
+                if (tokens.length == 2)
+                {
+                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]));
+                }
+                else if (tokens.length == 3)
+                {
+                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
+                }
+            }
+            catch (NumberFormatException e)
+            {
+                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
+            }
+        }
+        else
+        {
+            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+        }
+
+        return vertex;
+    }
+
+    private Vertex parseVertexNormal(String line, int lineCount) throws ModelFormatException
+    {
+        Vertex vertexNormal = null;
+
+        if (isValidVertexNormalLine(line))
+        {
+            line = line.substring(line.indexOf(" ") + 1);
+            String[] tokens = line.split(" ");
+
+            try
+            {
+                if (tokens.length == 3)
+                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
+            }
+            catch (NumberFormatException e)
+            {
+                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
+            }
+        }
+        else
+        {
+            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+        }
+
+        return vertexNormal;
+    }
+
+    private TextureCoordinate parseTextureCoordinate(String line, int lineCount) throws ModelFormatException
+    {
+        TextureCoordinate textureCoordinate = null;
+
+        if (isValidTextureCoordinateLine(line))
+        {
+            line = line.substring(line.indexOf(" ") + 1);
+            String[] tokens = line.split(" ");
+
+            try
+            {
+                if (tokens.length == 2)
+                    return new TextureCoordinate(Float.parseFloat(tokens[0]), 1 - Float.parseFloat(tokens[1]));
+                else if (tokens.length == 3)
+                    return new TextureCoordinate(Float.parseFloat(tokens[0]), 1 - Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
+            }
+            catch (NumberFormatException e)
+            {
+                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
+            }
+        }
+        else
+        {
+            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+        }
+
+        return textureCoordinate;
+    }
+
+    private S_Face parseFace(String line, int lineCount) throws ModelFormatException
+    {
+    	S_Face face = null;
+
+        if (isValidFaceLine(line))
+        {
+            face = new S_Face();
+
+            String trimmedLine = line.substring(line.indexOf(" ") + 1);
+            String[] tokens = trimmedLine.split(" ");
+            String[] subTokens = null;
+
+            if (tokens.length == 3)
+            {
+                if (currentGroupObject.glDrawingMode == -1)
+                {
+                    currentGroupObject.glDrawingMode = GL11.GL_TRIANGLES;
+                }
+                else if (currentGroupObject.glDrawingMode != GL11.GL_TRIANGLES)
+                {
+                    throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Invalid number of points for face (expected 4, found " + tokens.length + ")");
+                }
+            }
+            else if (tokens.length == 4)
+            {
+                if (currentGroupObject.glDrawingMode == -1)
+                {
+                    currentGroupObject.glDrawingMode = GL11.GL_QUADS;
+                }
+                else if (currentGroupObject.glDrawingMode != GL11.GL_QUADS)
+                {
+                    throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Invalid number of points for face (expected 3, found " + tokens.length + ")");
+                }
+            }
+
+            // f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3 ...
+            if (isValidFace_V_VT_VN_Line(line))
+            {
+                face.vertices = new Vertex[tokens.length];
+                face.textureCoordinates = new TextureCoordinate[tokens.length];
+                face.vertexNormals = new Vertex[tokens.length];
+
+                for (int i = 0; i < tokens.length; ++i)
+                {
+                    subTokens = tokens[i].split("/");
+
+                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
+                    face.textureCoordinates[i] = textureCoordinates.get(Integer.parseInt(subTokens[1]) - 1);
+                    face.vertexNormals[i] = vertexNormals.get(Integer.parseInt(subTokens[2]) - 1);
+                }
+
+                face.faceNormal = face.calculateFaceNormal();
+            }
+            // f v1/vt1 v2/vt2 v3/vt3 ...
+            else if (isValidFace_V_VT_Line(line))
+            {
+                face.vertices = new Vertex[tokens.length];
+                face.textureCoordinates = new TextureCoordinate[tokens.length];
+
+                for (int i = 0; i < tokens.length; ++i)
+                {
+                    subTokens = tokens[i].split("/");
+
+                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
+                    face.textureCoordinates[i] = textureCoordinates.get(Integer.parseInt(subTokens[1]) - 1);
+                }
+
+                face.faceNormal = face.calculateFaceNormal();
+            }
+            // f v1//vn1 v2//vn2 v3//vn3 ...
+            else if (isValidFace_V_VN_Line(line))
+            {
+                face.vertices = new Vertex[tokens.length];
+                face.vertexNormals = new Vertex[tokens.length];
+
+                for (int i = 0; i < tokens.length; ++i)
+                {
+                    subTokens = tokens[i].split("//");
+
+                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
+                    face.vertexNormals[i] = vertexNormals.get(Integer.parseInt(subTokens[1]) - 1);
+                }
+
+                face.faceNormal = face.calculateFaceNormal();
+            }
+            // f v1 v2 v3 ...
+            else if (isValidFace_V_Line(line))
+            {
+                face.vertices = new Vertex[tokens.length];
+
+                for (int i = 0; i < tokens.length; ++i)
+                {
+                    face.vertices[i] = vertices.get(Integer.parseInt(tokens[i]) - 1);
+                }
+
+                face.faceNormal = face.calculateFaceNormal();
+            }
+            else
+            {
+                throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+            }
+        }
+        else
+        {
+            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+        }
+
+        return face;
+    }
+
+    private S_GroupObject parseGroupObject(String line, int lineCount) throws ModelFormatException
+    {
+    	S_GroupObject group = null;
+
+        if (isValidGroupObjectLine(line))
+        {
+            String trimmedLine = line.substring(line.indexOf(" ") + 1);
+
+            if (trimmedLine.length() > 0)
+            {
+                group = new S_GroupObject(trimmedLine);
+            }
+        }
+        else
+        {
+            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
+        }
+
+        return group;
+    }
+
+    private static boolean isValidVertexLine(String line)
+    {
+        if (vertexMatcher != null)
+        {
+            vertexMatcher.reset();
+        }
+
+        vertexMatcher = vertexPattern.matcher(line);
+        return vertexMatcher.matches();
+    }
+
+    private static boolean isValidVertexNormalLine(String line)
+    {
+        if (vertexNormalMatcher != null)
+        {
+            vertexNormalMatcher.reset();
+        }
+
+        vertexNormalMatcher = vertexNormalPattern.matcher(line);
+        return vertexNormalMatcher.matches();
+    }
+
+    private static boolean isValidTextureCoordinateLine(String line)
+    {
+        if (textureCoordinateMatcher != null)
+        {
+            textureCoordinateMatcher.reset();
+        }
+
+        textureCoordinateMatcher = textureCoordinatePattern.matcher(line);
+        return textureCoordinateMatcher.matches();
+    }
+
+    private static boolean isValidFace_V_VT_VN_Line(String line)
+    {
+        if (face_V_VT_VN_Matcher != null)
+        {
+            face_V_VT_VN_Matcher.reset();
+        }
+
+        face_V_VT_VN_Matcher = face_V_VT_VN_Pattern.matcher(line);
+        return face_V_VT_VN_Matcher.matches();
+    }
+
+    private static boolean isValidFace_V_VT_Line(String line)
+    {
+        if (face_V_VT_Matcher != null)
+        {
+            face_V_VT_Matcher.reset();
+        }
+
+        face_V_VT_Matcher = face_V_VT_Pattern.matcher(line);
+        return face_V_VT_Matcher.matches();
+    }
+
+    private static boolean isValidFace_V_VN_Line(String line)
+    {
+        if (face_V_VN_Matcher != null)
+        {
+            face_V_VN_Matcher.reset();
+        }
+
+        face_V_VN_Matcher = face_V_VN_Pattern.matcher(line);
+        return face_V_VN_Matcher.matches();
+    }
+
+    private static boolean isValidFace_V_Line(String line)
+    {
+        if (face_V_Matcher != null)
+        {
+            face_V_Matcher.reset();
+        }
+
+        face_V_Matcher = face_V_Pattern.matcher(line);
+        return face_V_Matcher.matches();
+    }
+
+    private static boolean isValidFaceLine(String line)
+    {
+        return isValidFace_V_VT_VN_Line(line) || isValidFace_V_VT_Line(line) || isValidFace_V_VN_Line(line) || isValidFace_V_Line(line);
+    }
+
+    private static boolean isValidGroupObjectLine(String line)
+    {
+        if (groupObjectMatcher != null)
+        {
+            groupObjectMatcher.reset();
+        }
+
+        groupObjectMatcher = groupObjectPattern.matcher(line);
+        return groupObjectMatcher.matches();
+    }
+
+    @Override
+    public String getType()
+    {
+        return "obj";
+    }
+}

com/hbm/render/util/S_Face.java

@@ -0,0 +1,86 @@
+package com.hbm.render.util;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.Vec3;
+import net.minecraftforge.client.model.obj.TextureCoordinate;
+import net.minecraftforge.client.model.obj.Vertex;
+
+@SideOnly(Side.CLIENT)
+public class S_Face {
+	
+	public int[] verticesID;
+	public Vertex[] vertices;
+	public Vertex[] vertexNormals;
+	public Vertex faceNormal;
+	public TextureCoordinate[] textureCoordinates;
+
+	/*public S_Face copy() {
+		S_Face f = new S_Face();
+
+		return f;
+	}*/
+
+	public void addFaceForRender(Tessellator tessellator) {
+		addFaceForRender(tessellator, 0.0F);
+	}
+
+	public void addFaceForRender(Tessellator tessellator, float textureOffset) {
+		
+		if (this.faceNormal == null) {
+			this.faceNormal = calculateFaceNormal();
+		}
+		
+		tessellator.setNormal(this.faceNormal.x, this.faceNormal.y, this.faceNormal.z);
+
+		float averageU = 0.0F;
+		float averageV = 0.0F;
+		
+		if ((this.textureCoordinates != null) && (this.textureCoordinates.length > 0)) {
+			
+			for (int i = 0; i < this.textureCoordinates.length; i++) {
+				averageU += this.textureCoordinates[i].u;
+				averageV += this.textureCoordinates[i].v;
+			}
+			
+			averageU /= this.textureCoordinates.length;
+			averageV /= this.textureCoordinates.length;
+		}
+		
+		for (int i = 0; i < this.vertices.length; i++) {
+			
+			if ((this.textureCoordinates != null) && (this.textureCoordinates.length > 0)) {
+				
+				float offsetU = textureOffset;
+				float offsetV = textureOffset;
+				
+				if (this.textureCoordinates[i].u > averageU) {
+					offsetU = -offsetU;
+				}
+				if (this.textureCoordinates[i].v > averageV) {
+					offsetV = -offsetV;
+				}
+				if ((this.vertexNormals != null) && (i < this.vertexNormals.length)) {
+					tessellator.setNormal(this.vertexNormals[i].x, this.vertexNormals[i].y, this.vertexNormals[i].z);
+				}
+				
+				tessellator.addVertexWithUV(this.vertices[i].x, this.vertices[i].y, this.vertices[i].z, this.textureCoordinates[i].u + offsetU, this.textureCoordinates[i].v + offsetV);
+			
+			} else {
+				tessellator.addVertex(this.vertices[i].x, this.vertices[i].y, this.vertices[i].z);
+			}
+		}
+	}
+
+	public Vertex calculateFaceNormal() {
+		
+		Vec3 v1 = Vec3.createVectorHelper(this.vertices[1].x - this.vertices[0].x, this.vertices[1].y - this.vertices[0].y, this.vertices[1].z - this.vertices[0].z);
+		Vec3 v2 = Vec3.createVectorHelper(this.vertices[2].x - this.vertices[0].x, this.vertices[2].y - this.vertices[0].y, this.vertices[2].z - this.vertices[0].z);
+		Vec3 normalVector = null;
+
+		normalVector = v1.crossProduct(v2).normalize();
+
+		return new Vertex((float) normalVector.xCoord, (float) normalVector.yCoord, (float) normalVector.zCoord);
+	}
+}

com/hbm/render/util/S_GroupObject.java

@@ -0,0 +1,41 @@
+package com.hbm.render.util;
+
+import java.util.ArrayList;
+
+import net.minecraft.client.renderer.Tessellator;
+
+public class S_GroupObject {
+	public String name;
+	public ArrayList<S_Face> faces = new ArrayList();
+	public int glDrawingMode;
+
+	public S_GroupObject() {
+		this("");
+	}
+
+	public S_GroupObject(String name) {
+		this(name, -1);
+	}
+
+	public S_GroupObject(String name, int glDrawingMode) {
+		this.name = name;
+		this.glDrawingMode = glDrawingMode;
+	}
+
+	public void render() {
+		if (this.faces.size() > 0) {
+			Tessellator tessellator = Tessellator.instance;
+			tessellator.startDrawing(this.glDrawingMode);
+			render(tessellator);
+			tessellator.draw();
+		}
+	}
+
+	public void render(Tessellator tessellator) {
+		if (this.faces.size() > 0) {
+			for (S_Face face : this.faces) {
+				face.addFaceForRender(tessellator);
+			}
+		}
+	}
+}

com/hbm/render/util/S_ModelCustom.java

@@ -0,0 +1,79 @@
+package com.hbm.render.util;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraftforge.client.model.IModelCustom;
+import net.minecraftforge.client.model.obj.Vertex;
+
+@SideOnly(Side.CLIENT)
+public abstract class S_ModelCustom implements IModelCustom {
+	
+	public float min = 100000.0F;
+	public float minX = 100000.0F;
+	public float minY = 100000.0F;
+	public float minZ = 100000.0F;
+	public float max = -100000.0F;
+	public float maxX = -100000.0F;
+	public float maxY = -100000.0F;
+	public float maxZ = -100000.0F;
+	public float size = 0.0F;
+	public float sizeX = 0.0F;
+	public float sizeY = 0.0F;
+	public float sizeZ = 0.0F;
+
+	public void checkMinMax(Vertex v) {
+		if (v.x < this.minX) {
+			this.minX = v.x;
+		}
+		if (v.y < this.minY) {
+			this.minY = v.y;
+		}
+		if (v.z < this.minZ) {
+			this.minZ = v.z;
+		}
+		if (v.x > this.maxX) {
+			this.maxX = v.x;
+		}
+		if (v.y > this.maxY) {
+			this.maxY = v.y;
+		}
+		if (v.z > this.maxZ) {
+			this.maxZ = v.z;
+		}
+	}
+
+	public void checkMinMaxFinal() {
+		if (this.minX < this.min) {
+			this.min = this.minX;
+		}
+		if (this.minY < this.min) {
+			this.min = this.minY;
+		}
+		if (this.minZ < this.min) {
+			this.min = this.minZ;
+		}
+		if (this.maxX > this.max) {
+			this.max = this.maxX;
+		}
+		if (this.maxY > this.max) {
+			this.max = this.maxY;
+		}
+		if (this.maxZ > this.max) {
+			this.max = this.maxZ;
+		}
+		this.sizeX = (this.maxX - this.minX);
+		this.sizeY = (this.maxY - this.minY);
+		this.sizeZ = (this.maxZ - this.minZ);
+		this.size = (this.max - this.min);
+	}
+
+	public abstract boolean containsPart(String paramString);
+
+	public abstract void renderAll(int paramInt1, int paramInt2);
+
+	public abstract void renderAllLine(int paramInt1, int paramInt2);
+
+	public abstract int getVertexNum();
+
+	public abstract int getFaceNum();
+}