[solved]null pointer exception when rendering custom block in inventory.

[Kakarotvg]

As the title says I am having trouble rendering my custom block in the inventory, I got it to work with my chest, but with this block it doesn't work.  What I am trying to do is render the block model in the inventory with its texture, just like a custom chest would.

 

error log

 

  Reveal hidden contents

 

2013-09-01 19:33:07 [iNFO] [sTDERR] net.minecraft.util.ReportedException: Rendering screen

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.renderer.EntityRenderer.updateCameraAndRender(EntityRenderer.java:1045)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.Minecraft.runGameLoop(Minecraft.java:934)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.Minecraft.func_99999_d(Minecraft.java:826)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.main.Main.main(Main.java:93)

2013-09-01 19:33:07 [iNFO] [sTDERR] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

2013-09-01 19:33:07 [iNFO] [sTDERR] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

2013-09-01 19:33:07 [iNFO] [sTDERR] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)

2013-09-01 19:33:07 [iNFO] [sTDERR] at java.lang.reflect.Method.invoke(Method.java:597)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.launchwrapper.Launch.launch(Launch.java:57)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.launchwrapper.Launch.main(Launch.java:18)

2013-09-01 19:33:07 [iNFO] [sTDERR] Caused by: java.lang.NullPointerException

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.tileentity.TileEntity.getBlockType(TileEntity.java:226)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.tileentity.TileEntity.func_85027_a(TileEntity.java:285)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.renderer.tileentity.TileEntityRenderer.renderTileEntityAt(TileEntityRenderer.java:178)

2013-09-01 19:33:07 [iNFO] [sTDERR] at kakarotvg.omega.render.itemrender.ItemComputerRenderer.renderItem(ItemComputerRenderer.java:31)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraftforge.client.ForgeHooksClient.renderInventoryItem(ForgeHooksClient.java:158)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.renderer.entity.RenderItem.renderItemAndEffectIntoGUI(RenderItem.java:465)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.gui.inventory.GuiContainer.drawSlotInventory(GuiContainer.java:421)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.gui.inventory.GuiContainer.drawScreen(GuiContainer.java:132)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.renderer.InventoryEffectRenderer.drawScreen(InventoryEffectRenderer.java:43)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.gui.inventory.GuiContainerCreative.drawScreen(GuiContainerCreative.java:683)

2013-09-01 19:33:07 [iNFO] [sTDERR] at net.minecraft.client.renderer.EntityRenderer.updateCameraAndRender(EntityRenderer.java:1036)

2013-09-01 19:33:07 [iNFO] [sTDERR] ... 9 more

2013-09-01 19:33:07 [iNFO] [sTDOUT] ---- Minecraft Crash Report ----

2013-09-01 19:33:07 [iNFO] [sTDOUT] // I let you down. Sorry

2013-09-01 19:33:07 [iNFO] [sTDOUT]

2013-09-01 19:33:07 [iNFO] [sTDOUT] Time: 9/1/13 7:33 PM

2013-09-01 19:33:07 [iNFO] [sTDOUT] Description: Rendering screen

2013-09-01 19:33:07 [iNFO] [sTDOUT]

2013-09-01 19:33:07 [iNFO] [sTDOUT] java.lang.NullPointerException

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.tileentity.TileEntity.getBlockType(TileEntity.java:226)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.tileentity.TileEntity.func_85027_a(TileEntity.java:285)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.tileentity.TileEntityRenderer.renderTileEntityAt(TileEntityRenderer.java:178)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at kakarotvg.omega.render.itemrender.ItemComputerRenderer.renderItem(ItemComputerRenderer.java:31)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraftforge.client.ForgeHooksClient.renderInventoryItem(ForgeHooksClient.java:158)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.entity.RenderItem.renderItemAndEffectIntoGUI(RenderItem.java:465)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainer.drawSlotInventory(GuiContainer.java:421)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainer.drawScreen(GuiContainer.java:132)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.InventoryEffectRenderer.drawScreen(InventoryEffectRenderer.java:43)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainerCreative.drawScreen(GuiContainerCreative.java:683)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.EntityRenderer.updateCameraAndRender(EntityRenderer.java:1036)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.Minecraft.runGameLoop(Minecraft.java:934)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.Minecraft.func_99999_d(Minecraft.java:826)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.main.Main.main(Main.java:93)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at java.lang.reflect.Method.invoke(Method.java:597)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.launchwrapper.Launch.launch(Launch.java:57)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.launchwrapper.Launch.main(Launch.java:18)

2013-09-01 19:33:07 [iNFO] [sTDOUT]

2013-09-01 19:33:07 [iNFO] [sTDOUT]

2013-09-01 19:33:07 [iNFO] [sTDOUT] A detailed walkthrough of the error, its code path and all known details is as follows:

2013-09-01 19:33:07 [iNFO] [sTDOUT] ---------------------------------------------------------------------------------------

2013-09-01 19:33:07 [iNFO] [sTDOUT]

2013-09-01 19:33:07 [iNFO] [sTDOUT] -- Head --

2013-09-01 19:33:07 [iNFO] [sTDOUT] Stacktrace:

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.tileentity.TileEntity.getBlockType(TileEntity.java:226)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.tileentity.TileEntity.func_85027_a(TileEntity.java:285)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.tileentity.TileEntityRenderer.renderTileEntityAt(TileEntityRenderer.java:178)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at kakarotvg.omega.render.itemrender.ItemComputerRenderer.renderItem(ItemComputerRenderer.java:31)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraftforge.client.ForgeHooksClient.renderInventoryItem(ForgeHooksClient.java:158)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.entity.RenderItem.renderItemAndEffectIntoGUI(RenderItem.java:465)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainer.drawSlotInventory(GuiContainer.java:421)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainer.drawScreen(GuiContainer.java:132)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.renderer.InventoryEffectRenderer.drawScreen(InventoryEffectRenderer.java:43)

2013-09-01 19:33:07 [iNFO] [sTDOUT] at net.minecraft.client.gui.inventory.GuiContainerCreative.drawScreen(GuiContainerCreative.java:683)

 

 

 

clientproxy class

 

  Reveal hidden contents

 

package kakarotvg.omega.proxys;

 

import kakarotvg.omega.entity.mobs.EntityAnnihilator;

import kakarotvg.omega.entity.mobs.EntityEliminator;

import kakarotvg.omega.entity.mobs.EntityJungleAssasin;

import kakarotvg.omega.entity.mobs.EntityOmegaHound;

import kakarotvg.omega.entity.mobs.EntityOmegakiller;

import kakarotvg.omega.entity.mobs.EntitySlayer;

import kakarotvg.omega.entity.tileentity.TileEntityComputerEntity;

import kakarotvg.omega.entity.tileentity.TileEntityDarknessSolidEntity;

import kakarotvg.omega.handlers.tileentity.TileEntityHandler;

import kakarotvg.omega.model.ModelAnnihilator;

import kakarotvg.omega.model.ModelEliminator;

import kakarotvg.omega.model.ModelJungleAsasin;

import kakarotvg.omega.model.ModelOmegaHound;

import kakarotvg.omega.model.ModelOmegakiller;

import kakarotvg.omega.model.ModelSlayer;

import kakarotvg.omega.render.itemrender.ItemComputerRenderer;

import kakarotvg.omega.render.itemrender.UnderworldChestItemRender;

import kakarotvg.omega.render.mobs.RenderAnnihilator;

import kakarotvg.omega.render.mobs.RenderEliminator;

import kakarotvg.omega.render.mobs.RenderJungleAssasin;

import kakarotvg.omega.render.mobs.RenderOmegaHound;

import kakarotvg.omega.render.mobs.RenderOmegaKiller;

import kakarotvg.omega.render.mobs.RenderSlayer;

import kakarotvg.omega.render.tileentity.TileEntityComputerRenderer;

import kakarotvg.omega.render.tileentity.TileEntityDarknessSolidRenderer;

import kakarotvg.omega.render.tileentity.TileEntityUnderworldchestrenderer;

import kakarotvg.omega.tileentity.TileEntityUnderworldChest;

import net.minecraftforge.client.MinecraftForgeClient;

import cpw.mods.fml.client.registry.ClientRegistry;

import cpw.mods.fml.client.registry.RenderingRegistry;

 

public class ClientProxy extends CommonProxy {

 

    public void registerRenderInformation() {

        // Renders the Mobs

        RenderingRegistry.registerEntityRenderingHandler(EntityOmegaHound.class, new RenderOmegaHound(new ModelOmegaHound(), 0.05F));

        RenderingRegistry.registerEntityRenderingHandler(EntityOmegakiller.class, new RenderOmegaKiller(new ModelOmegakiller(), 0.5F));

        RenderingRegistry.registerEntityRenderingHandler(EntityEliminator.class, new RenderEliminator(new ModelEliminator(), 0.5F));

        RenderingRegistry.registerEntityRenderingHandler(EntitySlayer.class, new RenderSlayer(new ModelSlayer(), 0.5F));

        RenderingRegistry.registerEntityRenderingHandler(EntityAnnihilator.class, new RenderAnnihilator(new ModelAnnihilator(), 0.5F));

        RenderingRegistry.registerEntityRenderingHandler(EntityJungleAssasin.class, new RenderJungleAssasin(new ModelJungleAsasin(), 0.5F));

    }

 

    public void registerRenderThings() {

        ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDarknessSolidEntity.class, new TileEntityDarknessSolidRenderer());

        ClientRegistry.bindTileEntitySpecialRenderer(TileEntityComputerEntity.class, new TileEntityComputerRenderer());

        ClientRegistry.bindTileEntitySpecialRenderer(TileEntityUnderworldChest.class, new TileEntityUnderworldchestrenderer());

        MinecraftForgeClient.registerItemRenderer(TileEntityHandler.underworldchest.blockID, new UnderworldChestItemRender());

        MinecraftForgeClient.registerItemRenderer(TileEntityHandler.computer.blockID, new ItemComputerRenderer());

    }

 

    @Override

    public void registerRenders() {

 

    }

 

    @Override

    public int addArmor(String armor) {

        return RenderingRegistry.addNewArmourRendererPrefix(armor);

    }

 

}

 

 

 

 

ItemRenderer

 

  Reveal hidden contents

 

package kakarotvg.omega.render.itemrender;

 

import kakarotvg.omega.entity.tileentity.TileEntityComputerEntity;

import kakarotvg.omega.model.ModelComputer;

import net.minecraft.client.renderer.tileentity.TileEntityRenderer;

import net.minecraft.item.ItemStack;

import net.minecraftforge.client.IItemRenderer;

 

public class ItemComputerRenderer implements IItemRenderer {

 

    private ModelComputer computermodel;

 

    public ItemComputerRenderer() {

        computermodel = new ModelComputer();

    }

 

    @Override

    public boolean handleRenderType(ItemStack item, ItemRenderType type) {

        // TODO Auto-generated method stub

        return true;

    }

 

    @Override

    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {

        // TODO Auto-generated method stub

        return true;

    }

 

    @Override

    public void renderItem(ItemRenderType type, ItemStack item, Object... data) {

        TileEntityRenderer.instance.renderTileEntityAt(new TileEntityComputerEntity(), 0.0D, 0.0D, 0.0D, 0.0f);

    }

 

}

 

 

 

 

Tile entity handler

 

  Reveal hidden contents

 

package kakarotvg.omega.handlers.tileentity;

 

import kakarotvg.omega.blocks.UnderworldChest;

import kakarotvg.omega.entity.tileentity.TileEntityComputerEntity;

import kakarotvg.omega.entity.tileentity.TileEntityDarknessSolidEntity;

import kakarotvg.omega.handlers.IDs.IDHandler;

import kakarotvg.omega.handlers.creativetab.CreativetabHandler;

import kakarotvg.omega.tileentity.TileEntityComputer;

import kakarotvg.omega.tileentity.TileEntitySolidDarkness;

import kakarotvg.omega.tileentity.TileEntityUnderworldChest;

import net.minecraft.block.Block;

import net.minecraftforge.common.Configuration;

import cpw.mods.fml.common.registry.GameRegistry;

import cpw.mods.fml.common.registry.LanguageRegistry;

 

public class TileEntityHandler {

 

    public static Block darknesssolid;

    public static Block computer;

    public static Block computerburn;

    public static Block underworldchest;

 

    public static void configureTileEntitys(Configuration config) {

        darknesssolid = new TileEntitySolidDarkness(IDHandler.darknesssolidID).setUnlocalizedName("soliddarknessicon");

        computer = new TileEntityComputer(IDHandler.computeridleID, false).setUnlocalizedName("computericon").setCreativeTab(CreativetabHandler.vgtab);

        underworldchest = new UnderworldChest(IDHandler.underworldchestID, 0).setUnlocalizedName("underworldchest").setCreativeTab(CreativetabHandler.vgtab);

    }

 

    public static void registerTileEntitys(GameRegistry registry) {

        registry.registerBlock(darknesssolid, "darknesssolid");

        registry.registerBlock(computer, "computer");

        registry.registerBlock(underworldchest, "underworldchest");

    }

 

    public static void addNames(LanguageRegistry register) {

        register.addName(darknesssolid, "Darkness Extrapalator");

        register.addName(computer, "Laptop");

        register.addName(underworldchest, "Underworld Chest");

    }

 

    public static void tileentityRegistry(GameRegistry registry) {

        registry.registerTileEntity(TileEntityDarknessSolidEntity.class, "tileEntityDarknessSolid");

        registry.registerTileEntity(TileEntityComputerEntity.class, "tileEntityComputer");

        registry.registerTileEntity(TileEntityUnderworldChest.class, "TileEntityUnderworldChest");

    }

 

}

 

 

 

 

tileentitycomputerentity

 

  Reveal hidden contents

 

package kakarotvg.omega.entity.tileentity;

 

import kakarotvg.omega.computer.ComputerRecipes;

import kakarotvg.omega.tileentity.TileEntityComputer;

import net.minecraft.block.Block;

import net.minecraft.block.material.Material;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.inventory.IInventory;

import net.minecraft.item.Item;

import net.minecraft.item.ItemBlock;

import net.minecraft.item.ItemHoe;

import net.minecraft.item.ItemStack;

import net.minecraft.item.ItemSword;

import net.minecraft.item.ItemTool;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.nbt.NBTTagList;

import net.minecraft.tileentity.TileEntity;

import cpw.mods.fml.common.registry.GameRegistry;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class TileEntityComputerEntity extends TileEntity implements IInventory {

    private static final int[] slots_top = new int[] { 0 };

    private static final int[] slots_bottom = new int[] { 2, 1 };

    private static final int[] slots_sides = new int[] { 1 };

 

    /**

    * The ItemStacks that hold the items currently being used in the furnace

    */

    private ItemStack[] furnaceItemStacks = new ItemStack[3];

 

    /** The number of ticks that the furnace will keep burning */

    public int furnaceBurnTime;

 

    /**

    * The number of ticks that a fresh copy of the currently-burning item would

    * keep the furnace burning for

    */

    public int currentItemBurnTime;

 

    /** The number of ticks that the current item has been cooking for */

    public int furnaceCookTime;

    private String field_94130_e;

 

    /**

    * Returns the number of slots in the inventory.

    */

    public int getSizeInventory() {

        return this.furnaceItemStacks.length;

    }

 

    /**

    * Returns the stack in slot i

    */

    public ItemStack getStackInSlot(int par1) {

        return this.furnaceItemStacks[par1];

    }

 

    /**

    * Removes from an inventory slot (first arg) up to a specified number

    * (second arg) of items and returns them in a new stack.

    */

    public ItemStack decrStackSize(int par1, int par2) {

        if (this.furnaceItemStacks[par1] != null) {

            ItemStack itemstack;

 

            if (this.furnaceItemStacks[par1].stackSize <= par2) {

                itemstack = this.furnaceItemStacks[par1];

                this.furnaceItemStacks[par1] = null;

                return itemstack;

            }

            else {

                itemstack = this.furnaceItemStacks[par1].splitStack(par2);

 

                if (this.furnaceItemStacks[par1].stackSize == 0) {

                    this.furnaceItemStacks[par1] = null;

                }

 

                return itemstack;

            }

        }

        else {

            return null;

        }

    }

 

    /**

    * When some containers are closed they call this on each slot, then drop

    * whatever it returns as an EntityItem - like when you close a workbench

    * GUI.

    */

    public ItemStack getStackInSlotOnClosing(int par1) {

        if (this.furnaceItemStacks[par1] != null) {

            ItemStack itemstack = this.furnaceItemStacks[par1];

            this.furnaceItemStacks[par1] = null;

            return itemstack;

        }

        else {

            return null;

        }

    }

 

    /**

    * Sets the given item stack to the specified slot in the inventory (can be

    * crafting or armor sections).

    */

    public void setInventorySlotContents(int par1, ItemStack par2ItemStack) {

        this.furnaceItemStacks[par1] = par2ItemStack;

 

        if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) {

            par2ItemStack.stackSize = this.getInventoryStackLimit();

        }

    }

 

    /**

    * Returns the name of the inventory.

    */

    public String getInvName() {

        return this.isInvNameLocalized() ? this.field_94130_e : "Computer Furnace";

    }

 

    /**

    * If this returns false, the inventory name will be used as an unlocalized

    * name, and translated into the player's language. Otherwise it will be

    * used directly.

    */

    public boolean isInvNameLocalized() {

        return this.field_94130_e != null && this.field_94130_e.length() > 0;

    }

 

    /**

    * Sets the custom display name to use when opening a GUI linked to this

    * tile entity.

    */

    public void setGuiDisplayName(String par1Str) {

        this.field_94130_e = par1Str;

    }

 

    /**

    * Reads a tile entity from NBT.

    */

    public void readFromNBT(NBTTagCompound par1NBTTagCompound) {

        super.readFromNBT(par1NBTTagCompound);

        NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items");

        this.furnaceItemStacks = new ItemStack[this.getSizeInventory()];

 

        for (int i = 0; i < nbttaglist.tagCount(); ++i) {

            NBTTagCompound nbttagcompound1 = (NBTTagCompound) nbttaglist.tagAt(i);

            byte b0 = nbttagcompound1.getByte("Slot");

 

            if (b0 >= 0 && b0 < this.furnaceItemStacks.length) {

                this.furnaceItemStacks[b0] = ItemStack.loadItemStackFromNBT(nbttagcompound1);

            }

        }

 

        this.furnaceBurnTime = par1NBTTagCompound.getShort("BurnTime");

        this.furnaceCookTime = par1NBTTagCompound.getShort("CookTime");

        this.currentItemBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

 

        if (par1NBTTagCompound.hasKey("Computer Furnace")) {

            this.field_94130_e = par1NBTTagCompound.getString("Computer Furnace");

        }

    }

 

    /**

    * Writes a tile entity to NBT.

    */

    public void writeToNBT(NBTTagCompound par1NBTTagCompound) {

        super.writeToNBT(par1NBTTagCompound);

        par1NBTTagCompound.setShort("BurnTime", (short) this.furnaceBurnTime);

        par1NBTTagCompound.setShort("CookTime", (short) this.furnaceCookTime);

        NBTTagList nbttaglist = new NBTTagList();

 

        for (int i = 0; i < this.furnaceItemStacks.length; ++i) {

            if (this.furnaceItemStacks != null) {

                NBTTagCompound nbttagcompound1 = new NBTTagCompound();

                nbttagcompound1.setByte("Slot", (byte) i);

                this.furnaceItemStacks.writeToNBT(nbttagcompound1);

                nbttaglist.appendTag(nbttagcompound1);

            }

        }

 

        par1NBTTagCompound.setTag("Items", nbttaglist);

 

        if (this.isInvNameLocalized()) {

            par1NBTTagCompound.setString("Computer Furnace", this.field_94130_e);

        }

    }

 

    /**

    * Returns the maximum stack size for a inventory slot. Seems to always be

    * 64, possibly will be extended. *Isn't this more of a set than a get?*

    */

    public int getInventoryStackLimit() {

        return 64;

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * Returns an integer between 0 and the passed value representing how close the current item is to being completely

    * cooked

    */

    public int getCookProgressScaled(int par1) {

        return this.furnaceCookTime * par1 / 200;

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * Returns an integer between 0 and the passed value representing how much burn time is left on the current fuel

    * item, where 0 means that the item is exhausted and the passed value means that the item is fresh

    */

    public int getBurnTimeRemainingScaled(int par1) {

        if (this.currentItemBurnTime == 0) {

            this.currentItemBurnTime = 200;

        }

 

        return this.furnaceBurnTime * par1 / this.currentItemBurnTime;

    }

 

    /**

    * Returns true if the furnace is currently burning

    */

    public boolean isBurning() {

        return this.furnaceBurnTime > 0;

    }

 

    /**

    * Allows the entity to update its state. Overridden in most subclasses,

    * e.g. the mob spawner uses this to count ticks and creates a new spawn

    * inside its implementation.

    */

    public void updateEntity() {

        boolean flag = this.furnaceBurnTime > 0;

        boolean flag1 = false;

 

        if (this.furnaceBurnTime > 0) {

            --this.furnaceBurnTime;

        }

 

        if (!this.worldObj.isRemote) {

            if (this.furnaceBurnTime == 0 && this.canSmelt()) {

                this.currentItemBurnTime = this.furnaceBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

 

                if (this.furnaceBurnTime > 0) {

                    flag1 = true;

 

                    if (this.furnaceItemStacks[1] != null) {

                        --this.furnaceItemStacks[1].stackSize;

 

                        if (this.furnaceItemStacks[1].stackSize == 0) {

                            this.furnaceItemStacks[1] = this.furnaceItemStacks[1].getItem().getContainerItemStack(furnaceItemStacks[1]);

                        }

                    }

                }

            }

 

            if (this.isBurning() && this.canSmelt()) {

                ++this.furnaceCookTime;

 

                if (this.furnaceCookTime == 200) {

                    this.furnaceCookTime = 0;

                    this.smeltItem();

                    flag1 = true;

                }

            }

            else {

                this.furnaceCookTime = 0;

            }

 

            if (flag != this.furnaceBurnTime > 0) {

                flag1 = true;

                TileEntityComputer.updateFurnaceBlockState(this.furnaceBurnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }

        }

 

        if (flag1) {

            this.onInventoryChanged();

        }

    }

 

    /**

    * Returns true if the furnace can smelt an item, i.e. has a source item,

    * destination stack isn't full, etc.

    */

    private boolean canSmelt() {

        if (this.furnaceItemStacks[0] == null) {

            return false;

        }

        else {

            ItemStack itemstack = ComputerRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

            if (itemstack == null) return false;

            if (this.furnaceItemStacks[2] == null) return true;

            if (!this.furnaceItemStacks[2].isItemEqual(itemstack)) return false;

            int result = furnaceItemStacks[2].stackSize + itemstack.stackSize;

            return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());

        }

    }

 

    /**

    * Turn one item from the furnace source stack into the appropriate smelted

    * item in the furnace result stack

    */

    public void smeltItem() {

        if (this.canSmelt()) {

            ItemStack itemstack = ComputerRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

 

            if (this.furnaceItemStacks[2] == null) {

                this.furnaceItemStacks[2] = itemstack.copy();

            }

            else if (this.furnaceItemStacks[2].isItemEqual(itemstack)) {

                furnaceItemStacks[2].stackSize += itemstack.stackSize;

            }

 

            --this.furnaceItemStacks[0].stackSize;

 

            if (this.furnaceItemStacks[0].stackSize <= 0) {

                this.furnaceItemStacks[0] = null;

            }

        }

    }

 

    /**

    * Returns the number of ticks that the supplied fuel item will keep the

    * furnace burning, or 0 if the item isn't fuel

    */

    public static int getItemBurnTime(ItemStack par0ItemStack) {

        if (par0ItemStack == null) {

            return 0;

        }

        else {

            int i = par0ItemStack.getItem().itemID;

            Item item = par0ItemStack.getItem();

 

            if (par0ItemStack.getItem() instanceof ItemBlock && Block.blocksList != null) {

                Block block = Block.blocksList;

 

                if (block == Block.woodSingleSlab) {

                    return 150;

                }

 

                if (block.blockMaterial == Material.wood) {

                    return 300;

                }

 

                if (block == Block.field_111034_cE) {

                    return 16000;

                }

            }

 

            if (item instanceof ItemTool && ((ItemTool) item).getToolMaterialName().equals("WOOD")) return 200;

            if (item instanceof ItemSword && ((ItemSword) item).getToolMaterialName().equals("WOOD")) return 200;

            if (item instanceof ItemHoe && ((ItemHoe) item).getMaterialName().equals("WOOD")) return 200;

            if (i == Item.stick.itemID) return 100;

            if (i == Item.coal.itemID) return 1600;

            if (i == Item.bucketLava.itemID) return 20000;

            if (i == Block.sapling.blockID) return 100;

            if (i == Item.blazeRod.itemID) return 2400;

            return GameRegistry.getFuelValue(par0ItemStack);

        }

    }

 

    /**

    * Return true if item is a fuel source (getItemBurnTime() > 0).

    */

    public static boolean isItemFuel(ItemStack par0ItemStack) {

        return getItemBurnTime(par0ItemStack) > 0;

    }

 

    /**

    * Do not make give this method the name canInteractWith because it clashes

    * with Container

    */

    public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) {

        return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double) this.xCoord + 0.5D, (double) this.yCoord + 0.5D, (double) this.zCoord + 0.5D) <= 64.0D;

    }

 

    public void openChest() {

    }

 

    public void closeChest() {

    }

 

    /**

    * Returns true if automation is allowed to insert the given stack (ignoring

    * stack size) into the given slot.

    */

    public boolean isItemValidForSlot(int par1, ItemStack par2ItemStack) {

        return par1 == 2 ? false : (par1 == 1 ? isItemFuel(par2ItemStack) : true);

    }

 

    /**

    * Returns an array containing the indices of the slots that can be accessed

    * by automation on the given side of this block.

    */

    public int[] getAccessibleSlotsFromSide(int par1) {

        return par1 == 0 ? slots_bottom : (par1 == 1 ? slots_top : slots_sides);

    }

 

    /**

    * Returns true if automation can insert the given item in the given slot

    * from the given side. Args: Slot, item, side

    */

    public boolean canInsertItem(int par1, ItemStack par2ItemStack, int par3) {

        return this.isItemValidForSlot(par1, par2ItemStack);

    }

 

    /**

    * Returns true if automation can extract the given item in the given slot

    * from the given side. Args: Slot, item, side

    */

    public boolean canExtractItem(int par1, ItemStack par2ItemStack, int par3) {

        return par3 != 0 || par1 != 1 || par2ItemStack.itemID == Item.bucketEmpty.itemID;

    }

 

    @Override

    public void onInventoryChanged() {

        // TODO Auto-generated method stub

 

    }

}

 

 

 

 

renderer class

 

  Reveal hidden contents

 

package kakarotvg.omega.render.tileentity;

 

import kakarotvg.omega.Reference;

import kakarotvg.omega.model.ModelComputer;

import net.minecraft.block.Block;

import net.minecraft.client.Minecraft;

import net.minecraft.client.renderer.OpenGlHelper;

import net.minecraft.client.renderer.Tessellator;

import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;

import net.minecraft.entity.Entity;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.util.ResourceLocation;

import net.minecraft.world.World;

 

import org.lwjgl.opengl.GL11;

import org.lwjgl.opengl.GL12;

 

public class TileEntityComputerRenderer extends TileEntitySpecialRenderer {

 

    //The model of your block

    public final ModelComputer model;

    private static final ResourceLocation resourceloc = new ResourceLocation(Reference.MOD_ID + ":" + "textures/tileentity/computer.png");

 

    public TileEntityComputerRenderer() {

        this.model = new ModelComputer();

    }

 

    @Override

    public void renderTileEntityAt(TileEntity te, double x, double y, double z, float scale) {

        //The PushMatrix tells the renderer to "start" doing something.

        GL11.glPushMatrix();

 

        //This is setting the initial location.

        GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);

        //This is the texture of your block. It's pathed to be the same place as your other blocks here.

        //This rotation part is very important! Without it, your model will render upside-down! And for some reason you DO need PushMatrix again!                     

        GL11.glPushMatrix();

        GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

 

        adjustLightFixture(te.worldObj, te.xCoord, te.yCoord, te.zCoord, te.blockType);

        //A reference to your Model file. Again, very important.

        //Tell it to stop rendering for both the PushMatrix's

        GL11.glPopMatrix();

        GL11.glPopMatrix();

    }

 

    //Set the lighting stuff, so it changes it's brightness properly.     

    private void adjustLightFixture(World world, int i, int j, int k, Block block) {

 

        int dir = world.getBlockMetadata(i, j, k);

 

        GL11.glPushMatrix();

        //This line actually rotates the renderer.

        GL11.glRotatef(dir * (90F), 0F, 1F, 0F);

        Minecraft.getMinecraft().renderEngine.func_110577_a(resourceloc);

        this.model.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);

        /*

        * Place your rendering code here.

        */

 

        GL11.glPopMatrix();

 

    }

}

 

 

[GotoLink]

@Override
    public boolean handleRenderType(ItemStack item, ItemRenderType type) {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
        // TODO Auto-generated method stub
        return true;
    }

Try return false ?

 

Did you ClientRegistry.bindTileEntitySpecialRenderer(args); ?

[Kakarotvg]

render class is there now.

[Kakarotvg]

That line of code is required for my block to rotate based on the players position when placing it.

[Kakarotvg]

Got it working except the rotation isn't working correctly,

 

new render code

 

  Reveal hidden contents

 

package kakarotvg.omega.render.tileentity;

 

import kakarotvg.omega.Reference;

import kakarotvg.omega.model.ModelComputer;

import net.minecraft.block.Block;

import net.minecraft.client.Minecraft;

import net.minecraft.client.renderer.OpenGlHelper;

import net.minecraft.client.renderer.Tessellator;

import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;

import net.minecraft.entity.Entity;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.util.ResourceLocation;

import net.minecraft.world.World;

 

import org.lwjgl.opengl.GL11;

import org.lwjgl.opengl.GL12;

 

public class TileEntityComputerRenderer extends TileEntitySpecialRenderer {

 

    //The model of your block

    public final ModelComputer model;

    private static final ResourceLocation resourceloc = new ResourceLocation(Reference.MOD_ID + ":" + "textures/tileentity/computer.png");

 

    public TileEntityComputerRenderer() {

        this.model = new ModelComputer();

    }

 

    @Override

    public void renderTileEntityAt(TileEntity te, double x, double y, double z, float scale) {

        //The PushMatrix tells the renderer to "start" doing something.

        GL11.glPushMatrix();

 

        //This is setting the initial location.

        GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);

        //This is the texture of your block. It's pathed to be the same place as your other blocks here.

        //This rotation part is very important! Without it, your model will render upside-down! And for some reason you DO need PushMatrix again!                     

        GL11.glPushMatrix();

        GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

 

        adjustLightFixture(te.worldObj, te.xCoord, te.yCoord, te.zCoord, te.blockType);

        //A reference to your Model file. Again, very important.

        //Tell it to stop rendering for both the PushMatrix's

        GL11.glPopMatrix();

        GL11.glPopMatrix();

    }

 

    //Set the lighting stuff, so it changes it's brightness properly.     

    private void adjustLightFixture(World world, int i, int j, int k, Block block) {

        if (world != null) {

            int dir = world.getBlockMetadata(i, j, k);

 

            GL11.glPushMatrix();

            //This line actually rotates the renderer.

            GL11.glRotatef(dir * (90F), 0F, 1F, 0F);

            Minecraft.getMinecraft().renderEngine.func_110577_a(resourceloc);

            this.model.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);

            /*

            * Place your rendering code here.

            */

 

            GL11.glPopMatrix();

        }

        else {

            Minecraft.getMinecraft().renderEngine.func_110577_a(resourceloc);

            this.model.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);

        }

 

    }

}

 

 

 

 

this is what happens when I place it down.

 

  Reveal hidden contents

 

direction 1

direction 2

direction 3

direction 4

 

 

[Kakarotvg]

please help, the rotation isn't working the way it should, and I can't fix it.

[Kakarotvg]

Still need help please!!!

[Kakarotvg]

Never mind I fixed it, turns out I messed up something in the actual block code so This problem is solved

 

the problem with the rotation was in the tileentitycomputer class

 

  Reveal hidden contents

 

package kakarotvg.omega.tileentity;

 

import java.util.Random;

 

import kakarotvg.omega.Omega;

import kakarotvg.omega.Reference;

import kakarotvg.omega.entity.tileentity.TileEntityComputerEntity;

import kakarotvg.omega.handlers.creativetab.CreativetabHandler;

import kakarotvg.omega.handlers.tileentity.TileEntityHandler;

import net.minecraft.block.Block;

import net.minecraft.block.BlockContainer;

import net.minecraft.block.material.Material;

import net.minecraft.client.renderer.texture.IconRegister;

import net.minecraft.entity.EntityLivingBase;

import net.minecraft.entity.item.EntityItem;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.inventory.Container;

import net.minecraft.inventory.IInventory;

import net.minecraft.item.ItemStack;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.tileentity.TileEntityFurnace;

import net.minecraft.util.Icon;

import net.minecraft.util.MathHelper;

import net.minecraft.world.World;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class TileEntityComputer extends BlockContainer {

 

    /**

    * Is the random generator used by furnace to drop the inventory contents in

    * random directions.

    */

    private final Random furnaceRand = new Random();

 

    /** True if this is an active furnace, false if idle */

    private final boolean isActive;

 

    /**

    * This flag is used to prevent the furnace inventory to be dropped upon

    * block removal, is used internally when the furnace block changes from

    * idle to active and vice-versa.

    */

    private static boolean keepFurnaceInventory;

 

    public TileEntityComputer(int par1, boolean par2) {

        super(par1, Material.rock);

        this.isActive = par2;

    }

 

    /**

    * Returns the ID of the items to drop on destruction.

    */

    public int idDropped(int par1, Random par2Random, int par3) {

        return TileEntityHandler.computer.blockID;

    }

 

    /**

    * Called whenever the block is added into the world. Args: world, x, y, z

    */

    public void onBlockAdded(World par1World, int par2, int par3, int par4) {

        super.onBlockAdded(par1World, par2, par3, par4);

        this.setDefaultDirection(par1World, par2, par3, par4);

    }

 

    /**

    * set a blocks direction

    */

    private void setDefaultDirection(World par1World, int par2, int par3, int par4) {

        if (!par1World.isRemote) {

            int l = par1World.getBlockId(par2, par3, par4 - 1);

            int i1 = par1World.getBlockId(par2, par3, par4 + 1);

            int j1 = par1World.getBlockId(par2 - 1, par3, par4);

            int k1 = par1World.getBlockId(par2 + 1, par3, par4);

            byte b0 = 3;

 

            if (Block.opaqueCubeLookup[l] && !Block.opaqueCubeLookup[i1]) {

                b0 = 3;

            }

 

            if (Block.opaqueCubeLookup[i1] && !Block.opaqueCubeLookup[l]) {

                b0 = 2;

            }

 

            if (Block.opaqueCubeLookup[j1] && !Block.opaqueCubeLookup[k1]) {

                b0 = 5;

            }

 

            if (Block.opaqueCubeLookup[k1] && !Block.opaqueCubeLookup[j1]) {

                b0 = 4;

            }

 

            par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 2);

        }

    }

 

    @SideOnly(Side.CLIENT)

    @Override

    public void registerIcons(IconRegister register) {

        this.blockIcon = register.registerIcon(Reference.MOD_ID + ":" + (this.getUnlocalizedName().substring(5)));

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * When this method is called, your block should register all the icons it needs with the given IconRegister. This

    * is the only chance you get to register icons.

    */

    /**

    * Called upon block activation (right click on the block.)

    */

    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, float par8, float par9) {

        TileEntity tile_entity = world.getBlockTileEntity(x, y, z);

 

        if (tile_entity == null || player.isSneaking()) {

 

            return false;

        }

 

        player.openGui(Omega.instance, 0, world, x, y, z);

 

        return true;

    }

 

    /**

    * Update which block ID the furnace is using depending on whether or not it

    * is burning

    */

    public static void updateFurnaceBlockState(boolean par0, World par1World, int par2, int par3, int par4) {

        int l = par1World.getBlockMetadata(par2, par3, par4);

        TileEntity tileentity = par1World.getBlockTileEntity(par2, par3, par4);

        keepFurnaceInventory = true;

 

        if (par0) {

            par1World.setBlock(par2, par3, par4, TileEntityHandler.computerburn.blockID);

        }

        else {

            par1World.setBlock(par2, par3, par4, TileEntityHandler.computer.blockID);

        }

 

        keepFurnaceInventory = false;

        par1World.setBlockMetadataWithNotify(par2, par3, par4, l, 2);

 

        if (tileentity != null) {

            tileentity.validate();

            par1World.setBlockTileEntity(par2, par3, par4, tileentity);

        }

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * A randomly called display update to be able to add particles or other items for display

    */

    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {

        if (this.isActive) {

            int l = par1World.getBlockMetadata(par2, par3, par4);

            float f = (float) par2 + 0.5F;

            float f1 = (float) par3 + 0.0F + par5Random.nextFloat() * 6.0F / 16.0F;

            float f2 = (float) par4 + 0.5F;

            float f3 = 0.52F;

            float f4 = par5Random.nextFloat() * 0.6F - 0.3F;

 

            if (l == 4) {

                par1World.spawnParticle("smoke", (double) (f - f3), (double) f1, (double) (f2 + f4), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double) (f - f3), (double) f1, (double) (f2 + f4), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 5) {

                par1World.spawnParticle("smoke", (double) (f + f3), (double) f1, (double) (f2 + f4), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double) (f + f3), (double) f1, (double) (f2 + f4), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 2) {

                par1World.spawnParticle("smoke", (double) (f + f4), (double) f1, (double) (f2 - f3), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double) (f + f4), (double) f1, (double) (f2 - f3), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 3) {

                par1World.spawnParticle("smoke", (double) (f + f4), (double) f1, (double) (f2 + f3), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double) (f + f4), (double) f1, (double) (f2 + f3), 0.0D, 0.0D, 0.0D);

            }

        }

    }

 

    /**

    * Returns a new instance of a block's tile entity class. Called on placing

    * the block.

    */

    public TileEntity createNewTileEntity(World par1World) {

        return new TileEntityComputerEntity();

    }

 

    /**

    * Called when the block is placed in the world.

    */

    @Override

    public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack par6ItemStack) {

        int dir = MathHelper.floor_double((double) ((player.rotationYaw * 4F) / 360F) + 0.5D) & 3;

        world.setBlockMetadataWithNotify(x, y, z, dir, 0);

 

    }

 

    /**

    * ejects contained items into the world, and notifies neighbours of an

    * update, as appropriate

    */

    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6) {

        if (!keepFurnaceInventory) {

            TileEntityComputerEntity tileentitycomputer = (TileEntityComputerEntity) par1World.getBlockTileEntity(par2, par3, par4);

 

            if (tileentitycomputer != null) {

                for (int j1 = 0; j1 < tileentitycomputer.getSizeInventory(); ++j1) {

                    ItemStack itemstack = tileentitycomputer.getStackInSlot(j1);

 

                    if (itemstack != null) {

                        float f = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float f1 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float f2 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

 

                        while (itemstack.stackSize > 0) {

                            int k1 = this.furnaceRand.nextInt(21) + 10;

 

                            if (k1 > itemstack.stackSize) {

                                k1 = itemstack.stackSize;

                            }

 

                            itemstack.stackSize -= k1;

                            EntityItem entityitem = new EntityItem(par1World, (double) ((float) par2 + f), (double) ((float) par3 + f1), (double) ((float) par4 + f2), new ItemStack(itemstack.itemID, k1, itemstack.getItemDamage()));

 

                            if (itemstack.hasTagCompound()) {

                                entityitem.getEntityItem().setTagCompound((NBTTagCompound) itemstack.getTagCompound().copy());

                            }

 

                            float f3 = 0.05F;

                            entityitem.motionX = (double) ((float) this.furnaceRand.nextGaussian() * f3);

                            entityitem.motionY = (double) ((float) this.furnaceRand.nextGaussian() * f3 + 0.2F);

                            entityitem.motionZ = (double) ((float) this.furnaceRand.nextGaussian() * f3);

                            par1World.spawnEntityInWorld(entityitem);

                        }

                    }

                }

 

                par1World.func_96440_m(par2, par3, par4, par5);

            }

        }

 

        super.breakBlock(par1World, par2, par3, par4, par5, par6);

    }

 

    /**

    * If this returns true, then comparators facing away from this block will

    * use the value from getComparatorInputOverride instead of the actual

    * redstone signal strength.

    */

    public boolean hasComparatorInputOverride() {

        return true;

    }

 

    /**

    * If hasComparatorInputOverride returns true, the return value from this is

    * used instead of the redstone signal strength when this block inputs to a

    * comparator.

    */

    public int getComparatorInputOverride(World par1World, int par2, int par3, int par4, int par5) {

        return Container.calcRedstoneFromInventory((IInventory) par1World.getBlockTileEntity(par2, par3, par4));

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)

    */

    public int idPicked(World par1World, int par2, int par3, int par4) {

        return TileEntityHandler.computer.blockID;

    }

 

    //Make sure you set this as your TileEntity class relevant for the block!

 

    //You don't want the normal render type, or it wont render properly.

    @Override

    public int getRenderType() {

        return -1;

    }

 

    //It's not an opaque cube, so you need this.

    @Override

    public boolean isOpaqueCube() {

        return false;

    }

 

    //It's not a normal block, so you need this too.

    public boolean renderAsNormalBlock() {

        return false;

    }

 

}