[1.7.2]Custom Block Model Animation only updates when GUI is open ....

[Graphicscore]

Hey there i have an custom block with a TileEntity and a GUI I want that if the Block is working/smelting that its model starts to rotate a shape. The rotation is working but only if I open the Gui of the Block.

 

Block

 

  Reveal hidden contents

 

package net.graphicscore.blocks;

import java.util.Random;

import javax.swing.Icon;

import net.graphicscore.entities.TileEntityMasher;
import net.graphicscore.mod.FruityGraphic;
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
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.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import cpw.mods.fml.common.network.internal.FMLNetworkHandler;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class BlockMasher extends BlockContainer{

private final Random maceratorRand = new Random();

private final boolean isActive;

private static boolean keepMaceratorInventory;
@SideOnly(Side.CLIENT)
private IIcon maceratorIconTop;
private IIcon field_149935_N;
private IIcon field_149936_O;
public BlockMasher(boolean isActive) {
	super(Material.rock);

	this.isActive = isActive;
}

//@SideOnly(Side.CLIENT)	
 // public void registerBlockIcons(IIconRegister p_149651_1_)
   // {
//     
//	        this.field_149936_O = p_149651_1_.registerIcon(this.isActive ? FruityGraphic.MODID + ":" + "masher_front_lit" : FruityGraphic.MODID + ":" + "masher_front_idle");
//	        this.field_149935_N = p_149651_1_.registerIcon("furnace_top");
	//this.blockIcon = p_149651_1_.registerIcon(FruityGraphic.MODID +":"+"masher");
    //}

//	@SideOnly(Side.CLIENT)
//    public IIcon getIcon(int p_149691_1_, int p_149691_2_)
//    {
//        return p_149691_1_ == 1 ? this.field_149935_N : (p_149691_1_ == 0 ? this.field_149935_N : (p_149691_1_ != p_149691_2_ ? this.blockIcon : this.field_149936_O));
//    }


public int getRenderType()
{
	return -1;
}

public boolean isOpaqueCube()
{
	return false;
}

public boolean renderAsNormalBlock()
{
	return false;
}
/**
 * Returns the Item/Block to drop
 */
public Block idDropped(int par1, Random par2Random, int par3)
{
	return FruityGraphic.blockMasherIdle;
}   

/**
 * 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.func_149930_e(par1World, par2, par3, par4);
}

/**
 * set a blocks direction
 */
//	  private void func_149930_e(World p_149930_1_, int p_149930_2_, int p_149930_3_, int p_149930_4_)
//	    {
//	        if (!p_149930_1_.isRemote)
//	        {
//	            Block block = p_149930_1_.getBlock(p_149930_2_, p_149930_3_, p_149930_4_ - 1);
//	            Block block1 = p_149930_1_.getBlock(p_149930_2_, p_149930_3_, p_149930_4_ + 1);
//	            Block block2 = p_149930_1_.getBlock(p_149930_2_ - 1, p_149930_3_, p_149930_4_);
//	            Block block3 = p_149930_1_.getBlock(p_149930_2_ + 1, p_149930_3_, p_149930_4_);
//	            byte b0 = 3;
//
//	            if (block.func_149730_j() && !block1.func_149730_j())
//	            {
//	                b0 = 3;
//	            }
//
//	            if (block1.func_149730_j() && !block.func_149730_j())
//	            {
//	                b0 = 2;
//	            }
//
//	            if (block2.func_149730_j() && !block3.func_149730_j())
//	            {
//	                b0 = 5;
//	            }
//
//	            if (block3.func_149730_j() && !block2.func_149730_j())
//	            {
//	                b0 = 4;
//	            }
//
//	            p_149930_1_.setBlockMetadataWithNotify(p_149930_2_, p_149930_3_, p_149930_4_, b0, 2);
//	        }
//	    }

public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) {
	if(!world.isRemote) {
		FMLNetworkHandler.openGui(player, FruityGraphic.instance, FruityGraphic.guiIdMasher, 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.getTileEntity(par2, par3, par4);
	keepMaceratorInventory = true;

	if (par0)
	{
		par1World.setBlock(par2, par3, par4, FruityGraphic.blockMasherActive);
	}
	else
	{
		par1World.setBlock(par2, par3, par4, FruityGraphic.blockMasherIdle);
	}

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

	if (tileentity != null)
	{
		tileentity.validate();
		par1World.setTileEntity(par2, par3, par4, tileentity);
	}
}


/**
 * Called when the block is placed in the world.
 */
public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLivingBase, ItemStack par6ItemStack)
{
	int l = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

	if (l == 0)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 2, 2);
	}

	if (l == 1)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 5, 2);
	}

	if (l == 2)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 3, 2);
	}

	if (l == 3)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 4, 2);
	}

	if (par6ItemStack.hasDisplayName())
	{
		((TileEntityMasher)par1World.getTileEntity(par2, par3, par4)).setGuiDisplayName(par6ItemStack.getDisplayName());
	}

	int dir = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360F) + 0.5D) & 3;
	par1World.setBlockMetadataWithNotify(par2, par3, par4, 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, Block par5, int par6)
{
	if (!keepMaceratorInventory)
	{
		TileEntityMasher TileEntityMacerator = (TileEntityMasher)par1World.getTileEntity(par2, par3, par4);

		if (TileEntityMacerator != null)
		{
			for (int j1 = 0; j1 < TileEntityMacerator.getSizeInventory(); ++j1)
			{
				ItemStack itemstack = TileEntityMacerator.getStackInSlot(j1);

				if (itemstack != null)
				{
					float f = this.maceratorRand.nextFloat() * 0.8F + 0.1F;
					float f1 = this.maceratorRand.nextFloat() * 0.8F + 0.1F;
					float f2 = this.maceratorRand.nextFloat() * 0.8F + 0.1F;

					while (itemstack.stackSize > 0)
					{
						int k1 = this.maceratorRand.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.getItem(), k1, itemstack.getItemDamage()));

						if (itemstack.hasTagCompound())
						{
							entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
						}

						float f3 = 0.05F;
						entityitem.motionX = (double)((float)this.maceratorRand.nextGaussian() * f3);
						entityitem.motionY = (double)((float)this.maceratorRand.nextGaussian() * f3 + 0.2F);
						entityitem.motionZ = (double)((float)this.maceratorRand.nextGaussian() * f3);
						par1World.spawnEntityInWorld(entityitem);
					}
				}
			}

			par1World.func_147453_f(par2, par3, par4, FruityGraphic.blockMasherIdle);

		}
	}

	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.getTileEntity(par2, par3, par4));
}

@SideOnly(Side.CLIENT)

/**
 * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
 */
public Block idPicked(World par1World, int par2, int par3, int par4)
{
	return FruityGraphic.blockMasherIdle;
}

@Override
public TileEntity createNewTileEntity(World var1, int var2) {
	return new TileEntityMasher();
}

}

 

 

 

TileEntity

 

  Reveal hidden contents

 

package net.graphicscore.entities;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.graphicscore.blocks.BlockMasher;
import net.graphicscore.other.MasherRecipes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.FurnaceRecipes;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.Constants.NBT;
import net.minecraftforge.oredict.OreDictionary;

public class TileEntityMasher extends TileEntity implements ISidedInventory{
	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[] slots = new ItemStack[3];

	/** the speed of this furnace, 200 is normal / how many ticks it takes : 30 ticks = 1 second */
	public int mashingSpeed = 100;

	/** The number of ticks that the furnace will keep burning */
	public int power;
	public int maxPower = 15000;
	/** The number of ticks that the current item has been cooking for */
	public int cookTime;

	private String field_94130_e;

    	/**
     	* Returns the number of slots in the inventory.
     	*/
    	public int getSizeInventory()
    	{
        	return this.slots.length;
    	}

    	/**
     	* Returns the stack in slot i
     	*/
    	public ItemStack getStackInSlot(int par1)
    	{
        	return this.slots[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.slots[par1] != null)
        	{
            		ItemStack itemstack;

            		if (this.slots[par1].stackSize <= par2)
           		{
                		itemstack = this.slots[par1];
                		this.slots[par1] = null;
               			return itemstack;
            		}
            		else
            		{
                		itemstack = this.slots[par1].splitStack(par2);

                		if (this.slots[par1].stackSize == 0)
                		{
                    			this.slots[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.slots[par1] != null)
        	{
            		ItemStack itemstack = this.slots[par1];
            		this.slots[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.slots[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 : "container.macerator";
    	}

    	/**
     	* 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",NBT.TAG_COMPOUND);
        	this.slots = new ItemStack[this.getSizeInventory()];

        	for (int i = 0; i < nbttaglist.tagCount(); ++i)
        	{
            		NBTTagCompound nbttagcompound1 = (NBTTagCompound)nbttaglist.getCompoundTagAt(i);
            		byte b0 = nbttagcompound1.getByte("Slot");

            		if (b0 >= 0 && b0 < this.slots.length)
            		{
                		this.slots[b0] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
            		}
        	}

        	this.power = par1NBTTagCompound.getShort("power");
        	this.cookTime = par1NBTTagCompound.getShort("CookTime");
        	if (par1NBTTagCompound.hasKey("CustomName"))
        	{
            	this.field_94130_e = par1NBTTagCompound.getString("CustomName");
        	}
    	}

    	/**
     	* Writes a tile entity to NBT.
     	*/
    	public void writeToNBT(NBTTagCompound par1NBTTagCompound)
    	{
        	super.writeToNBT(par1NBTTagCompound);
        	par1NBTTagCompound.setShort("power", (short)this.power);
        	par1NBTTagCompound.setShort("CookTime", (short)this.cookTime);
        	
        	NBTTagList nbttaglist = new NBTTagList();

        	for (int i = 0; i < this.slots.length; ++i)
        	{	
            		if (this.slots[i] != null)
            		{
                		NBTTagCompound nbttagcompound1 = new NBTTagCompound();
                		nbttagcompound1.setByte("Slot", (byte)i);
                		this.slots[i].writeToNBT(nbttagcompound1);
                		nbttaglist.appendTag(nbttagcompound1);
            		}
        	}

        	par1NBTTagCompound.setTag("Items", nbttaglist);

        	if (this.isInvNameLocalized())
        	{
            		par1NBTTagCompound.setString("CustomName", 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.cookTime * par1 / this.mashingSpeed;
    	}
    
    	public int getPowerRemainingScaled(int par1){
        	return this.power * par1 / this.maxPower;
    	}

    	/**
     	* Returns true if the furnace is currently burning
     	*/
    	public boolean hasPower()
    	{
        	return this.power > 0;
    	}
    
    	public boolean isMacerating(){
    		return this.cookTime > 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.power > 0;
        	boolean flag1 = false;
    	
        	if (hasPower() && isMacerating()){
            		this.power--;
        	}

        	if (!this.worldObj.isRemote){
            	if (this.power < this.maxPower && this.getItemPower(this.slots[1]) > 0){
            		this.power += getItemPower(this.slots[1]);

            		flag1 = true;
            	
            		if (this.slots[1] != null){
                    		this.slots[1].stackSize--;
                    		if (this.slots[1].stackSize == 0){
                    			
                        		this.slots[1] =  this.slots[1].getItem().getContainerItem(slots[1]);
                    		}
                	}                
            	}

            	if (this.hasPower() && this.canMash())
            	{
                	++this.cookTime;

                	if (this.cookTime == this.mashingSpeed)
                	{
                    	this.cookTime = 0;
                    	this.smeltItem();
                   	flag1 = true;
                	}
            	}
            	else
            	{
                	this.cookTime = 0;
            	}

            	if (flag != this.power > 0)
            	{
                	flag1 = true;
                		BlockMasher.updateFurnaceBlockState(this.power > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
            		}	
        	}

        	if (flag1){
            		this.updateEntity();
        	}
        	
    	}
    


    	private boolean canMash(){
        	if (this.slots[0] == null){
            	return false;
        	}else{
            		ItemStack itemstack = MasherRecipes.smelting().getSmeltingResult(this.slots[0]);
            		if(itemstack == null) return false;
            		if(this.slots[2] == null) return true;
            		if(!this.slots[2].isItemEqual(itemstack)) return false;
            		int result = slots[2].stackSize + (itemstack.stackSize*2);
            		return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());
        	}
    	}


    	public void smeltItem(){
        	if(this.canMash()){
            	ItemStack itemstack = MasherRecipes.smelting().getSmeltingResult(this.slots[0]);
            
            	if(this.slots[2] == null){
                	this.slots[2] = itemstack.copy();
                	this.slots[2].stackSize*=2;
            	}else if (this.slots[2].isItemEqual(itemstack)){
                	slots[2].stackSize += (itemstack.stackSize * MasherRecipes.smelting().getSmeltingAmount(this.slots[0].getItem()));
            	}

            	--this.slots[0].stackSize;

            	if(this.slots[0].stackSize <= 0){
                	this.slots[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 getItemPower(ItemStack par0ItemStack){
        	if (par0ItemStack == null){
            	return 0;
        	}else{
        		Item i = par0ItemStack.getItem();
        	
        		if (i == Items.redstone) return 16;
            	return 0;
        	}
    	}

    	/**
     	* Return true if item is a fuel source (getItempower() > 0).
     	*/
    	public static boolean isItemFuel(ItemStack par0ItemStack)
    	{
        	return getItemPower(par0ItemStack) > 0;
    	}

    	/**
     	* Do not make give this method the name canInteractWith because it clashes with Container
     	*/
    	public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)
    	{
        	return this.worldObj.getTileEntity(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.getItem() == Items.bucket;
	}


	public String getInventoryName() {

		return "MasherInventory";
	}


	public boolean hasCustomInventoryName() {

		return false;
	}


	public void openInventory() {


	}


	public void closeInventory() {

	}

}

 

 

 

 

Model

 

  Reveal hidden contents

 

package net.graphicscore.models;

import net.graphicscore.entities.TileEntityMasher;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;

public class ModelMasher extends ModelBase
{
    ModelRenderer Left;
    ModelRenderer Right;
    ModelRenderer Back;
    ModelRenderer Front;
    ModelRenderer BackHandle;
    ModelRenderer Misher;
    ModelRenderer TopHandle;
    ModelRenderer Shape1;
  
  public ModelMasher()
  {
    textureWidth = 64;
    textureHeight = 64;
    
      Left = new ModelRenderer(this, 0, 0);
      Left.addBox(0F, 0F, 0F, 1, 16, 16);
      Left.setRotationPoint(8F, 8F, 7F);
      Left.setTextureSize(64, 64);
      Left.mirror = true;
      setRotation(Left, 0F, -1.578941F, 0F);
      Right = new ModelRenderer(this, 0, 0);
      Right.addBox(0F, 0F, 0F, 1, 16, 16);
      Right.setRotationPoint(8F, 8F, -8F);
      Right.setTextureSize(64, 64);
      Right.mirror = true;
      setRotation(Right, 0F, -1.578941F, 0F);
      Back = new ModelRenderer(this, 0, 0);
      Back.addBox(0F, 0F, 0F, 1, 16, 16);
      Back.setRotationPoint(7F, 8F, -8F);
      Back.setTextureSize(64, 64);
      Back.mirror = true;
      setRotation(Back, 0F, 0F, 0F);
      Front = new ModelRenderer(this, 0, 0);
      Front.addBox(0F, 0F, 0F, 1, 16, 16);
      Front.setRotationPoint(-8F, 8F, -8F);
      Front.setTextureSize(64, 64);
      Front.mirror = true;
      setRotation(Front, 0F, 0F, 0F);
      BackHandle = new ModelRenderer(this, 34, 0);
      BackHandle.addBox(0F, 0F, 0F, 2, 8, 2);
      BackHandle.setRotationPoint(7F, 1F, -1F);
      BackHandle.setTextureSize(64, 64);
      BackHandle.mirror = true;
      setRotation(BackHandle, 0F, 0F, 0F);
      Misher = new ModelRenderer(this, 42, 0);
      Misher.addBox(6F, 0F, 0F, 1, 12, 1);
      Misher.setRotationPoint(0F, 2F, -0.5F);
      Misher.setTextureSize(64, 64);
      Misher.mirror = true;
      setRotation(Misher, 0F, 0F, 0F);
      TopHandle = new ModelRenderer(this, 0, 49);
      TopHandle.addBox(0F, 0F, 0F, 14, 1, 14);
      TopHandle.setRotationPoint(-7F, 1F, -7F);
      TopHandle.setTextureSize(64, 64);
      TopHandle.mirror = true;
      setRotation(TopHandle, 0F, 0F, 0F);
      Shape1 = new ModelRenderer(this, 0, 32);
      Shape1.addBox(0F, 0F, 0F, 16, 1, 16);
      Shape1.setRotationPoint(-8F, 23F, -8F);
      Shape1.setTextureSize(64, 64);
      Shape1.mirror = true;
      setRotation(Shape1, 0F, 0F, 0F);
  }
  
  public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
  {
    super.render(entity, f, f1, f2, f3, f4, f5);
    setRotationAngles(f, f1, f2, f3, f4, f5, entity);
    Left.render(f5);
    Right.render(f5);
    Back.render(f5);
    Front.render(f5);
    BackHandle.render(f5);
    Misher.render(f5);
    TopHandle.render(f5);
    Shape1.render(f5);
  }
  
  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }
  
  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
  {
    super.setRotationAngles(f, f1, f2, f3, f4, f5,entity);
  }

  public void setMisherAngle(float f)
  {
  Misher.rotateAngleX = f;
  }
  public void renderModel(float f) 
  {

  Left.render(f);
  Right.render(f);
  Back.render(f);
  Front.render(f);
  BackHandle.render(f);
  Misher.render(f);
  TopHandle.render(f);
  Shape1.render(f);
  }

}

 

 

 

 

Renderer

 

  Reveal hidden contents

 

package net.graphicscore.renderer;

import org.lwjgl.opengl.GL11;

import net.graphicscore.entities.TileEntityMasher;
import net.graphicscore.mod.FruityGraphic;
import net.graphicscore.models.ModelMasher;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;


public class RendererMasher extends TileEntitySpecialRenderer{

private ModelMasher model;
private static final ResourceLocation texture = new ResourceLocation(FruityGraphic.MODID,  "textures/model/BlockMasher.png");
public RendererMasher()
{
	this.model = new ModelMasher();
}
public void renderTileEntityAt(TileEntity var1, double x, double y, double z, float var8) 
{
	TileEntityMasher tile = (TileEntityMasher) var1;
	int dir = tile.getBlockMetadata();
	GL11.glPushMatrix();
	GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F,(float)z + 0.5F);
	GL11.glRotatef(180F, 0, 0F, 1F);
	if(dir == 1)
	{
		GL11.glRotatef(360F, 0, 1F, 0F);
	}
	else if(dir == 2)
	{
	GL11.glRotatef(90F, 0F, 1F, 0F);
	}
	else if(dir == 3)
	{
		GL11.glRotatef(180F, 0, 1F, 0F);
	}
	else if(dir == 0)
	{
		GL11.glRotatef(270F, 0, 1F, 0F);
	}
	this.bindTexture(texture);
	GL11.glPushMatrix();
	model.setMisherAngle(tile.cookTime); [b]// HERE IT ROTATES THE SHAPE TO AN NUMBER GIVEN BY THE ENTITY BUT IT ONLY UPDATES WHEN THE GUI IS OPEN[/b]
	tile.updateEntity();
	tile.updateContainingBlockInfo();
	tile.validate();
	model.renderModel(0.0625F);
	GL11.glPopMatrix();
	GL11.glPopMatrix();
}

}

 

 

 

 

~Graphic

[sequituri]

This may be a case of client/server synchronization. I believe TileEntity is considered a server object, and it is synced when the GUI is open by the gui code. However, if you have no way of telling the client that the TE has changed (cooktime on the server), you may need to try a start_rotating and stop_rotating packet (from server to client). I'm just guessing here, but I'd make a breakpoint at the place where you change the model instance and see what the TE says.