[1.12.2] TileEntitySpecialRenderer Animation

[ChampionAsh5357]

Hello. I've created a sort of slot/lottery machine in which I am working on getting the animations working. However, the only animation that seems to work is the lever. The other ones for the spinners that line up and the button that you push does not seem to do the animation. Any help is appreciated.

 

Tile Entity

  Reveal hidden contents

package com.championash5357.custom.tileentity;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Nullable;

import com.championash5357.custom.block.BlockLotteryMachine;
import com.championash5357.custom.init.CustomItems;
import com.championash5357.custom.registry.CoinType;

import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.play.server.SPacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ITickable;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class TileEntityLotteryMachine extends TileEntity implements ITickable{
    
    private Map<CoinType, Integer> coins = new HashMap<CoinType, Integer>();
    public float leverAngle = 0F, prevLeverAngle = 0F, buttonOffset = 0F, prevButtonOffset = 0F, spinner1Angle = 0F, spinner2Angle = 0F, spinner3Angle = 0F, prevSpinner1Angle = 0F, prevSpinner2Angle = 0F, prevSpinner3Angle = 0F;
    public boolean leverPulled = false, buttonPushed = false;
    private int timesPushed = 0;
    private boolean[] activeSpinners = new boolean[] {false, false, false};
    
    @Override
    public void update() {
        this.prevLeverAngle = this.leverAngle;
        this.prevButtonOffset = this.buttonOffset;
        this.prevSpinner1Angle = this.spinner1Angle;
        this.prevSpinner2Angle = this.spinner2Angle;
        this.prevSpinner3Angle = this.spinner3Angle;
        
        if(leverPulled) {
            this.leverAngle = Math.min(this.leverAngle + .1F, .7F);
            if(leverAngle == .7F) leverPulled = false;
        } else this.leverAngle = Math.max(this.leverAngle - .02F, 0);
        
        if(buttonPushed) {
            this.buttonOffset = Math.min(this.buttonOffset + .002F, .03F);
            if(buttonOffset == .03F) buttonPushed = false;
        } else this.buttonOffset = Math.max(this.buttonOffset - .001F, 0F);
        
        if(activeSpinners[0]) {
            this.spinner1Angle += 1F;
            if(spinner1Angle >= 4F && prevSpinner1Angle >= 4F) {spinner1Angle -= 4F; prevSpinner1Angle -= 4F;}
        } else spinner1Angle = Math.round(spinner1Angle);
        
        if(activeSpinners[1]) {
            this.spinner2Angle += 1F;
            if(spinner2Angle >= 4F && prevSpinner2Angle >= 4F) {spinner2Angle -= 4F; prevSpinner2Angle -= 4F;}
        } else spinner2Angle = Math.round(spinner2Angle);
        
        if(activeSpinners[2]) {
            this.spinner3Angle += 1F;
            if(spinner3Angle >= 4F && prevSpinner3Angle >= 4F) {spinner3Angle -= 4F; prevSpinner3Angle -= 4F;}
        } else spinner3Angle = Math.round(spinner3Angle);
    }
    
    @Override
    public void readFromNBT(NBTTagCompound compound) {
        super.readFromNBT(compound);
        this.leverAngle = compound.getFloat("LeverAngle");
        this.prevLeverAngle = compound.getFloat("PrevLeverAngle");
        this.leverPulled = compound.getBoolean("LeverPulled");
        this.buttonOffset = compound.getFloat("ButtonOffset");
        this.prevButtonOffset = compound.getFloat("PrevButtonOffset");
        this.buttonPushed = compound.getBoolean("ButtonPushed");
        this.timesPushed = compound.getInteger("TimesPushed");
        this.spinner1Angle = compound.getFloat("Spinner1Angle");
        this.spinner2Angle = compound.getFloat("Spinner2Angle");
        this.spinner3Angle = compound.getFloat("Spinner3Angle");
        this.prevSpinner1Angle = compound.getFloat("PrevSpinner1Angle");
        this.prevSpinner2Angle = compound.getFloat("PrevSpinner2Angle");
        this.prevSpinner3Angle = compound.getFloat("PrevSpinner3Angle");
        this.activeSpinners[0] = compound.getBoolean("ActiveSpinner1");
        this.activeSpinners[1] = compound.getBoolean("ActiveSpinner2");
        this.activeSpinners[2] = compound.getBoolean("ActiveSpinner3");
        NBTTagList list = compound.getTagList("Coins", Constants.NBT.TAG_COMPOUND);
        for(int i = 0; i < list.tagCount(); i++) {
            NBTTagCompound coin = list.getCompoundTagAt(i);
            coins.put(CoinType.getTypeFromName(coin.getString("Type")), coin.getInteger("Amount"));
        }
    }
    
    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        super.writeToNBT(compound);
        compound.setFloat("LeverAngle", this.leverAngle);
        compound.setFloat("PrevLeverAngle", this.prevLeverAngle);
        compound.setBoolean("LeverPulled", this.leverPulled);
        compound.setFloat("ButtonOffset", this.buttonOffset);
        compound.setFloat("PrevButtonOffset", this.prevButtonOffset);
        compound.setBoolean("ButtonPushed", this.buttonPushed);
        compound.setInteger("TimesPushed", this.timesPushed);
        compound.setFloat("Spinner1Angle", this.spinner1Angle);
        compound.setFloat("Spinner2Angle", this.spinner2Angle);
        compound.setFloat("Spinner3Angle", this.spinner3Angle);
        compound.setFloat("PrevSpinner1Angle", this.prevSpinner1Angle);
        compound.setFloat("PrevSpinner2Angle", this.prevSpinner2Angle);
        compound.setFloat("PrevSpinner3Angle", this.prevSpinner3Angle);
        compound.setBoolean("ActiveSpinner1", this.activeSpinners[0]);
        compound.setBoolean("ActiveSpinner2", this.activeSpinners[1]);
        compound.setBoolean("ActiveSpinner3", this.activeSpinners[2]);
        NBTTagList list = new NBTTagList();
        for(CoinType coin : coins.keySet()) {
            NBTTagCompound tag = new NBTTagCompound();
            tag.setString("Type", coin.getName());
            tag.setInteger("Amount", coins.get(coin));
            list.appendTag(tag);
        }
        compound.setTag("Coins", list);
        return compound;
    }
    
    @Override
    public NBTTagCompound getUpdateTag() {
        return this.writeToNBT(new NBTTagCompound());
    }
    
    @Override
    public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
        this.readFromNBT(pkt.getNbtCompound());
    }
    
    @Override
    public SPacketUpdateTileEntity getUpdatePacket() {
        return new SPacketUpdateTileEntity(this.pos, 0, this.getUpdateTag());
    }
    
    public Map<CoinType, Integer> getCoinList() {
        return coins;
    }
    
    public void insertCoin(CoinType coin) {
        if(coins.containsKey(coin)) coins.put(coin, coins.get(coin) + 1);
        else coins.put(coin, 1);
        markDirty();
    }
    
    public void useCoin() {
        for(CoinType coin : coins.keySet()) {
            coins.put(coin, coins.get(coin) - 1);
            if(coins.get(coin).equals(0)) coins.remove(coin);
            return;
        }
    }
    
    public void pushButton() {
        buttonPushed = true;
        activeSpinners[timesPushed] = false;
        timesPushed += 1;
        markDirty();
    }
    
    public void activateSpinners() {
        activeSpinners[0] = true;
        activeSpinners[1] = true;
        activeSpinners[2] = true;
    }
    
    public void startMachine() {
        this.spinner1Angle = this.spinner2Angle = this.spinner3Angle = 0F;
        this.timesPushed = 0;
        useCoin();
        leverPulled = true;
        activateSpinners();
        markDirty();
    }
    
    public boolean canStart() {
        return leverAngle == 0F;
    }
    
    public boolean isFinished() {
        return activeSpinners[2] == false;
    }
    
    public boolean canPressButton() {
        return buttonOffset == 0F;
    }
    
    public void dropInventory() {
        for(CoinType coin : coins.keySet()) {
            for(int amount = 0; amount < coins.get(coin); ++amount) {
                EntityItem item = new EntityItem(world, pos.getX(), pos.getY(), pos.getZ(), CoinType.createCoin(new ItemStack(CustomItems.COIN), coin));
                world.spawnEntity(item);
            }
        }
    }
    
    @SideOnly(Side.CLIENT)
    public boolean isTop() {
        return BlockLotteryMachine.isTop(this.getBlockMetadata());
    }
}

 

Renderer (The few ones commented out were for testing purposes)

  Reveal hidden contents

package com.championash5357.custom.render;

import com.championash5357.custom.client.Reference;
import com.championash5357.custom.model.ModelLotteryMachine;
import com.championash5357.custom.tileentity.TileEntityLotteryMachine;

import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.MathHelper;

public class RenderTileEntityLotteryMachine extends TileEntitySpecialRenderer<TileEntityLotteryMachine> {
    
    private static final ResourceLocation TEXTURE = new ResourceLocation(Reference.MOD_ID, "textures/models/lottery_machine.png");
    protected static final ResourceLocation[] DESTROY_STAGES = new ResourceLocation[] {new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_0.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_1.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_2.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_3.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_4.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_5.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_6.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_7.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_8.png"), new ResourceLocation(Reference.MOD_ID, "textures/models/destroy_stages/lottery_machine/destroy_stage_9.png")};

    private ModelLotteryMachine machine = new ModelLotteryMachine();
    
    final double spinner_rotation = Math.PI / 2;
    
    @Override
    public void render(TileEntityLotteryMachine te, double x, double y, double z, float partialTicks, int destroyStage, float alpha) {
        boolean flag = te.getWorld() != null;
        boolean flag1 = flag ? te.isTop() : false;
        int i = flag ? te.getBlockMetadata() & 3 : 0;
        
        if (destroyStage >= 0) {
            this.bindTexture(DESTROY_STAGES[destroyStage]);
            GlStateManager.matrixMode(5890);
            GlStateManager.pushMatrix();
            GlStateManager.matrixMode(5888);
        } else {
            this.bindTexture(TEXTURE);
        }

        if(flag) this.renderPiece(flag1, x, y, z, i, alpha, te, partialTicks);
        else {
            GlStateManager.pushMatrix();
            this.renderPiece(false, x, y, z, i, alpha, te, partialTicks);
            this.renderPiece(true, x, y + 1.0D, z, i, alpha, te, partialTicks);
            GlStateManager.popMatrix();
        }

        if (destroyStage >= 0) {
            GlStateManager.matrixMode(5890);
            GlStateManager.popMatrix();
            GlStateManager.matrixMode(5888);
        }
    }
    
    private void renderPiece(boolean is_top, double x, double y, double z, int meta, float alpha, TileEntityLotteryMachine te, float partialTicks) {
        this.machine.preparePiece(is_top);
        GlStateManager.pushMatrix();
        float f = 0.0F;
        float f1 = is_top ? 0.5F : 1.5F;

        if (meta == EnumFacing.NORTH.getHorizontalIndex())
            f = 0.0F;
        else if (meta == EnumFacing.SOUTH.getHorizontalIndex()) {
            f = 180.0F;
        }
        else if (meta == EnumFacing.WEST.getHorizontalIndex()) {
            f = -90.0F;
        }
        else if (meta == EnumFacing.EAST.getHorizontalIndex()) {
            f = 90.0F;
        }

        GlStateManager.translate((float)x + .5F, (float)y + f1, (float)z + .5F);
        GlStateManager.rotate(180.0F, 1.0F, 0.0F, 0.0F);
        GlStateManager.rotate(f, 0.0F, 1.0F, 0.0F);
        GlStateManager.enableRescaleNormal();
        GlStateManager.pushMatrix();
        renderModel(te, partialTicks);
        GlStateManager.popMatrix();
        GlStateManager.color(1.0F, 1.0F, 1.0F, alpha);
        GlStateManager.popMatrix();
    }
    
    /*Work on animation*/
    private void renderModel(TileEntityLotteryMachine te, float partialTicks) {
        this.machine.Lever.rotateAngleX = te.prevLeverAngle + (te.leverAngle - te.prevLeverAngle) * partialTicks;
        this.machine.Panel_1.offsetY = te.prevButtonOffset + (te.buttonOffset - te.prevButtonOffset) * partialTicks;
        this.machine.Spinner.rotateAngleX = (float) (te.prevSpinner1Angle * spinner_rotation + (te.spinner1Angle * spinner_rotation - te.prevSpinner1Angle * spinner_rotation) * partialTicks);
        //this.machine.Spinner_1.rotateAngleX = (float) (te.spinner2Angle * Math.PI / 2);
        //this.machine.Spinner_2.rotateAngleX = (float) (te.spinner3Angle * Math.PI / 2);
        this.machine.render();
    }
}

 

Model

  Reveal hidden contents

package com.championash5357.custom.model;

import java.util.Collections;
import java.util.List;

import javax.vecmath.Matrix4f;
import javax.vecmath.Quat4f;
import javax.vecmath.Vector3f;

import org.apache.commons.lang3.tuple.Pair;

import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.client.renderer.block.model.IBakedModel;
import net.minecraft.client.renderer.block.model.ItemCameraTransforms.TransformType;
import net.minecraft.client.renderer.block.model.ItemOverrideList;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.util.EnumFacing;

public class ModelLotteryMachine extends ModelBase {
    
    public ModelRenderer Base;
    public ModelRenderer Base_1;
    public ModelRenderer Base_2;
    public ModelRenderer Base_3;
    public ModelRenderer Base_4;
    public ModelRenderer Lever;
    public ModelRenderer Lever_1;
    public ModelRenderer Lever_2;
    public ModelRenderer Top;
    public ModelRenderer Panel;
    public ModelRenderer Spinner;
    public ModelRenderer Spinner_1;
    public ModelRenderer Spinner_2;
    public ModelRenderer Panel_1;

    public ModelLotteryMachine() {
        this.textureWidth = 128;
        this.textureHeight = 128;
        this.Lever_2 = new ModelRenderer(this, 0, 38);
        this.Lever_2.setRotationPoint(7.0F, 20.25F, 0.0F);
        this.Lever_2.addBox(-1.0F, -12.0F, -1.0F, 2, 2, 2, -0.25F);
        this.Panel_1 = new ModelRenderer(this, 0, 84);
        this.Panel_1.setRotationPoint(-4.0F, 7.0F, -5.0F);
        this.Panel_1.addBox(0.0F, 0.0F, 0.0F, 4, 1, 4, 0.0F);
        this.setRotateAngle(Panel_1, 0.3141592653589793F, 0.0F, 0.0F);
        this.Panel = new ModelRenderer(this, 0, 68);
        this.Panel.setRotationPoint(-6.0F, 8.0F, -6.0F);
        this.Panel.addBox(0.0F, 0.0F, 0.0F, 12, 3, 7, 0.0F);
        this.setRotateAngle(Panel, 0.3141592653589793F, 0.0F, 0.0F);
        this.Base_1 = new ModelRenderer(this, 0, 0);
        this.Base_1.setRotationPoint(-6.0F, 18.0F, -6.0F);
        this.Base_1.addBox(0.0F, 0.0F, 0.0F, 12, 6, 12, 0.0F);
        this.Base_2 = new ModelRenderer(this, 0, 38);
        this.Base_2.setRotationPoint(-6.0F, 16.0F, -4.0F);
        this.Base_2.addBox(0.0F, 0.0F, 0.0F, 12, 2, 10, 0.0F);
        this.Spinner_2 = new ModelRenderer(this, 0, 78);
        this.Spinner_2.setRotationPoint(3.5F, 0.5F, 0.5F);
        this.Spinner_2.addBox(-1.5F, -1.5F, -1.5F, 3, 3, 3, 0.0F);
        this.Base_4 = new ModelRenderer(this, 0, 4);
        this.Base_4.setRotationPoint(2.0F, 16.0F, -6.0F);
        this.Base_4.addBox(0.0F, 0.0F, 0.0F, 4, 2, 2, 0.0F);
        this.Lever_1 = new ModelRenderer(this, 0, 18);
        this.Lever_1.setRotationPoint(7.0F, 20.0F, 0.0F);
        this.Lever_1.addBox(-0.5F, -10.0F, -0.5F, 1, 9, 1, 0.0F);
        this.Spinner_1 = new ModelRenderer(this, 0, 78);
        this.Spinner_1.setRotationPoint(0.0F, 0.5F, 0.5F);
        this.Spinner_1.addBox(-1.5F, -1.5F, -1.5F, 3, 3, 3, 0.0F);
        this.Lever = new ModelRenderer(this, 0, 8);
        this.Lever.setRotationPoint(7.0F, 20.0F, 0.0F);
        this.Lever.addBox(-1.0F, -1.0F, -1.0F, 2, 2, 2, 0.0F);
        this.Top = new ModelRenderer(this, 0, 50);
        this.Top.setRotationPoint(-6.0F, -4.0F, 0.0F);
        this.Top.addBox(0.0F, 0.0F, 0.0F, 12, 12, 6, 0.0F);
        this.Spinner = new ModelRenderer(this, 0, 78);
        this.Spinner.setRotationPoint(-3.5F, 0.5F, 0.5F);
        this.Spinner.addBox(-1.5F, -1.5F, -1.5F, 3, 3, 3, 0.0F);
        this.Base = new ModelRenderer(this, 0, 18);
        this.Base.setRotationPoint(-6.0F, 8.0F, -6.0F);
        this.Base.addBox(0.0F, 0.0F, 0.0F, 12, 8, 12, 0.0F);
        this.Base_3 = new ModelRenderer(this, 0, 0);
        this.Base_3.setRotationPoint(-6.0F, 16.0F, -6.0F);
        this.Base_3.addBox(0.0F, 0.0F, 0.0F, 4, 2, 2, 0.0F);
    }

    public void render() { 
        this.Lever_1.rotateAngleX = this.Lever.rotateAngleX;
        this.Lever_2.rotateAngleX = this.Lever.rotateAngleX;
        
        this.Base.render(0.0625F);
        this.Base_1.render(0.0625F);
        this.Base_2.render(0.0625F);
        this.Base_3.render(0.0625F);
        this.Base_4.render(0.0625F);
        this.Panel.render(0.0625F);
        this.Top.render(0.0625F);
        
        this.Lever.render(0.0625F);
        this.Lever_1.render(0.0625F);
        this.Lever_2.render(0.0625F);
        
        this.Spinner.render(0.0625F);
        this.Spinner_1.render(0.0625F);
        this.Spinner_2.render(0.0625F);
        
        this.Panel_1.render(0.0625F);
    }

    public void setRotateAngle(ModelRenderer modelRenderer, float x, float y, float z) {
        modelRenderer.rotateAngleX = x;
        modelRenderer.rotateAngleY = y;
        modelRenderer.rotateAngleZ = z;
    }
    
    public void preparePiece(boolean is_top) {
        this.Base.showModel = !is_top;
        this.Base_1.showModel = !is_top;
        this.Base_2.showModel = !is_top;
        this.Base_3.showModel = !is_top;
        this.Base_4.showModel = !is_top;
        this.Lever.showModel = !is_top;
        this.Lever_1.showModel = !is_top;
        this.Lever_2.showModel = !is_top;
        this.Panel.showModel = is_top;
        this.Panel_1.showModel = is_top;
        this.Top.showModel = is_top;
        this.Spinner.showModel = is_top;
        this.Spinner_1.showModel = is_top;
        this.Spinner_2.showModel = is_top;
    }
    
    public static class ModelItemLotteryMachine implements IBakedModel {

        @Override
        public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
            return Collections.EMPTY_LIST;
        }

        @Override
        public boolean isAmbientOcclusion() {
            return false;
        }

        @Override
        public boolean isGui3d() {
            return false;
        }

        @Override
        public boolean isBuiltInRenderer() {
            return true;
        }

        @Override
        public TextureAtlasSprite getParticleTexture() {
            return Minecraft.getMinecraft().getTextureMapBlocks().getMissingSprite();
        }

        @Override
        public ItemOverrideList getOverrides() {
            return ItemOverrideList.NONE;
        }
        
        @Override
        public Pair<? extends IBakedModel, Matrix4f> handlePerspective(TransformType cameraTransformType) {
            switch(cameraTransformType) {
            case FIRST_PERSON_RIGHT_HAND:
            case FIRST_PERSON_LEFT_HAND:
            case THIRD_PERSON_RIGHT_HAND:
            case THIRD_PERSON_LEFT_HAND:
                return Pair.of(this, new Matrix4f(new Quat4f(0, 1, 0, 0), new Vector3f(0, 0, 0), 0.5F));
            case FIXED:
                return Pair.of(this, new Matrix4f(new Quat4f(0, 0, 0, 1), new Vector3f(0, -.2F, 0), 0.5F));
            case GROUND:
            case GUI:
                return Pair.of(this, new Matrix4f(new Quat4f(0, 3, 0, 1), new Vector3f(0, -.2F, 0), 0.5F));
            default:
                return IBakedModel.super.handlePerspective(cameraTransformType);
            }
        }
    }
}