Java 类net.minecraftforge.common.property.IExtendedBlockState 实例源码

private List<IBakedModel> getSubModels(IExtendedBlockState state) {
    List<IBakedModel> subModels = new ArrayList<IBakedModel>();

    for (int i = 0; i < 6; i++) {
        if (state.getValue(BlockPipe.CONNECTIONS[i]) > 0) {
            subModels.add(connections[i]);
        } else {
            subModels.add(nodeSides[i]);
        }
        if (state.getValue(BlockPipe.CONNECTIONS[i]) > 1) {
            subModels.add(endings[i]);
        }
    }

    return subModels;
}

@Override
public EnumActionResult onItemUseFirst(EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, EnumHand hand) {

    if (!world.isRemote) {

        if (world.getBlockState(pos) instanceof IExtendedBlockState) {

            if(world.getTileEntity(pos) != null && world.getTileEntity(pos) instanceof TileTube) {

                IExtendedBlockState state = (IExtendedBlockState) world.getBlockState(pos);
                ItemStack held = player.getHeldItem(hand);
                int col = held.getItemDamage();

                state = state.withProperty(BlockTube.COLOR, col);
                world.setBlockState(pos, state);

                ((TileTube) world.getTileEntity(pos)).setTubeColor(col);
                PacketHandler.sendToAll(new PacketTubeSync(world.getTileEntity(pos), col));
                return EnumActionResult.SUCCESS;
            }
        }
    }

    return EnumActionResult.PASS;
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    if (state instanceof IExtendedBlockState) {
        IExtendedBlockState result = (IExtendedBlockState) state;
        if (world.getTileEntity(pos) != null && world.getTileEntity(pos) instanceof TileTube) {
            result = result.withProperty(UP, TubeUtil.canConnect(EnumFacing.UP, pos, world));
            result = result.withProperty(DOWN, TubeUtil.canConnect(EnumFacing.DOWN, pos, world));
            result = result.withProperty(NORTH, TubeUtil.canConnect(EnumFacing.NORTH, pos, world));
            result = result.withProperty(SOUTH, TubeUtil.canConnect(EnumFacing.SOUTH, pos, world));
            result = result.withProperty(EAST, TubeUtil.canConnect(EnumFacing.EAST, pos, world));
            result = result.withProperty(WEST, TubeUtil.canConnect(EnumFacing.WEST, pos, world));

            result = result.withProperty(COLOR, ((TileTube) world.getTileEntity(pos)).getTubeColor());
            return result;
        }
    }
    return state;
}

@Override
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {

    TileEntity tile = source.getTileEntity(pos);
    if (tile != null && tile instanceof TileTube) {
        state = this.getExtendedState(state, source, pos);
        if (state instanceof IExtendedBlockState) {
            IExtendedBlockState extState = (IExtendedBlockState) state;

            float minX = extState.getValue(WEST) ? MIN_BOUND : LOWER_BOUND;
            float minY = extState.getValue(DOWN) ? MIN_BOUND : LOWER_BOUND;
            float minZ = extState.getValue(NORTH) ? MIN_BOUND : LOWER_BOUND;
            float maxX = extState.getValue(EAST) ? MAX_BOUND : UPPER_BOUND;
            float maxY = extState.getValue(UP) ? MAX_BOUND : UPPER_BOUND;
            float maxZ = extState.getValue(SOUTH) ? MAX_BOUND : UPPER_BOUND;

            return new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ);
        }
    }

    return new AxisAlignedBB(LOWER_BOUND, LOWER_BOUND, LOWER_BOUND, UPPER_BOUND, UPPER_BOUND, UPPER_BOUND);
}

@Override
public List<BakedQuad> getQuads(IBlockState blockState, EnumFacing side, long rand)
{
    if (side != null) return ImmutableList.of();
    if (quads == null)
    {
        quads = buildQuads(this.state);
    }
    if (blockState instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState) blockState;
        if (exState.getUnlistedNames().contains(Properties.AnimationProperty))
        {

            IModelState newState = exState.getValue(Properties.AnimationProperty);
            if (newState != null)
            {
                newState = new ModelStateComposition(this.state, newState);
                return buildQuads(newState);
            }
        }
    }
    return quads;
}

public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand)
{
    BakedFluid model = this;
    if(state instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState)state;
        int[] cornerRound = getCorners(Optional.of(exState));
        int flowRound = getFlow(Optional.of(exState));
        long key = flowRound + 1024;
        for(int i = 3; i >= 0; i--)
        {
            key <<= 10;
            key |= cornerRound[i];
        }
        key <<= 1;
        key |= 1;
        model = modelCache.getUnchecked(key);
    }
    if(side == null) return ImmutableList.of();
    return model.faceQuads.get(side);
}

@SuppressWarnings ({ "unchecked", "deprecation" })
public static Map<BlockRenderLayer, Map<EnumFacing, List<BakedQuad>>> generateLayerFaceQuadMap(IExtendedBlockState state) {
    Map<BlockRenderLayer, Map<EnumFacing, TextureAtlasSprite>> layerFaceSpriteMap = state.getValue(BlockBakeryProperties.LAYER_FACE_SPRITE_MAP);
    Map<BlockRenderLayer, Map<EnumFacing, List<BakedQuad>>> layerFaceQuadMap = new HashMap<>();
    for (BlockRenderLayer layer : layerFaceSpriteMap.keySet()) {
        Map<EnumFacing, TextureAtlasSprite> faceSpriteMap = layerFaceSpriteMap.get(layer);
        Map<EnumFacing, List<BakedQuad>> faceQuadMap = new HashMap<>();
        for (EnumFacing face : faceSpriteMap.keySet()) {
            List<BakedQuad> quads = new LinkedList<>();
            quads.add(PlanarFaceBakery.bakeFace(face, faceSpriteMap.get(face)));
            faceQuadMap.put(face, quads);
        }
        layerFaceQuadMap.put(layer, faceQuadMap);
    }
    return layerFaceQuadMap;
}

@Override
public List<BakedQuad> bakeQuads(EnumFacing face, IExtendedBlockState state) {
    BakingVertexBuffer buffer = BakingVertexBuffer.create();
    Triple<Integer, Integer, UVTransformation> worldData = getWorldTransforms(state);
    CCRenderState ccrs = CCRenderState.instance();
    ccrs.reset();
    ccrs.startDrawing(0x7, DefaultVertexFormats.ITEM, buffer);
    models[worldData.getLeft()][worldData.getMiddle()].render(ccrs, worldData.getRight());
    buffer.finishDrawing();
    List<BakedQuad> quads = buffer.bake();
    if (face == null && !shouldCull()) {
        return quads;
    } else if (face != null) {
        return VertexDataUtils.sortFaceData(quads).get(face);
    }
    return ImmutableList.of();
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
    if (state instanceof IExtendedBlockState) {
        IBakedModel model;
        IBlockState renderState;
        TileEntityHidden te = ((IExtendedBlockState) state).getValue(BlockHiddenRenderOld.DATA);
        if (te.isRenderOld()) {
            IBlockState old = te.getRenderState();
            model = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(old);
            renderState = old;
        } else {
            model = models.getOrDefault(te.getRender(), missing);
            renderState = Blocks.STONE.getDefaultState();
        }
        return model.getQuads(renderState, side, rand);
    }
    return Collections.emptyList();
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess worldIn, BlockPos pos, PartDuct<?> duct) {
    if (state instanceof IExtendedBlockState) {
        IExtendedBlockState s = (IExtendedBlockState) state;
        /*state = s.withProperty(TYPE, type).withProperty(COLOR, color)
                .withProperty(DOWN, getPropertyValue(EnumFacing.DOWN))
                .withProperty(UP, getPropertyValue(EnumFacing.UP))
                .withProperty(NORTH, getPropertyValue(EnumFacing.NORTH))
                .withProperty(SOUTH, getPropertyValue(EnumFacing.SOUTH))
                .withProperty(WEST, getPropertyValue(EnumFacing.WEST))
                .withProperty(EAST, getPropertyValue(EnumFacing.EAST))
                .withProperty(CHANNEL, channel);*/
        return s.withProperty(DATA, ((PartStorageNetworkCable) duct).getData());
    }
    return state;
}

@Override
public List<BakedQuad> getQuads(@Nullable IBlockState state, @Nullable EnumFacing side, long rand) {
    if (side != null)
        return Collections.emptyList();
    TerminalFacing f = TerminalFacing.NORTH;
    TerminalColor color = new TerminalColor(CableColor.FLUIX);
    TileEntityBasicTerminal.TerminalState termS = TileEntityBasicTerminal.TerminalState.OFF;
    if (state != null) {
        IExtendedBlockState s = (IExtendedBlockState) state;
        f = s.getValue(BasicTerminal.FACING);
        color = s.getValue(BasicTerminal.COLOR);
        termS = s.getValue(BasicTerminal.STATE);
    }
    f = f == null ? TerminalFacing.NORTH : f;
    color = color == null ? new TerminalColor(CableColor.FLUIX) : color;
    termS = termS == null ? TileEntityBasicTerminal.TerminalState.OFF : termS;
    return getQuads(f, color.getColor(), color.getColorAlt(), termS, state, side, rand);
}

@Override
public List<BakedQuad> getQuads(@Nullable IBlockState state, @Nullable EnumFacing side, long rand) {
    if (side != null)
        return Collections.emptyList();
    TerminalFacing f = TerminalFacing.NORTH;
    TerminalColor color = new TerminalColor(CableColor.FLUIX);
    TileEntityBasicTerminal.TerminalState termS = TileEntityBasicTerminal.TerminalState.OFF;
    int ct = 0;
    if (state != null) {
        IExtendedBlockState s = (IExtendedBlockState) state;
        f = s.getValue(BasicTerminal.FACING);
        color = s.getValue(BasicTerminal.COLOR);
        termS = s.getValue(BasicTerminal.STATE);
        ct = s.getValue(b.STATE);
    }
    f = f == null ? TerminalFacing.NORTH : f;
    color = color == null ? new TerminalColor(CableColor.FLUIX) : color;
    termS = termS == null ? TileEntityBasicTerminal.TerminalState.OFF : termS;
    return getQuads(f, color.getColor(), color.getColorAlt(), termS, state, side, ConnectionType.VALUES[ct], rand);
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing s, long rand) {
    /*List<BakedQuad>[][] models = new List[3][64];
    for(int i = 0;i<models.length;i++)for(int j = 0;j<models[i].length;j++)models[i][j] = new ArrayList<>();
    for(int st = 0;st<models.length;st++){
        for(int j = 0;j<models[st].length;j++){
            List<EnumFacing> conn = new ArrayList<>();
            for(EnumFacing f : EnumFacing.VALUES){
                if(connects(j, f)){
                    conn.add(f);
                }
            }
            for(EnumFacing side : EnumFacing.VALUES){
                models[st][j].addAll(quads[st].get(side)[getModel(conn, side)]);
            }
        }
    }*/
    int conn = 0;
    if (state instanceof IExtendedBlockState) {
        Byte c = ((IExtendedBlockState) state).getValue(AdvStorageSystemRouter.CONNECTIONS);
        if (c != null)
            conn = c;
    }
    return models[state.getValue(AdvStorageSystemRouter.STATE)][conn];
}

@Override
protected IBakedModel buildModel (IBlockState state, IBakedModel parent) {
    try {
        EnumCompDrawer drawer = (EnumCompDrawer)state.getValue(BlockBitDrawers.SLOTS);
        EnumFacing dir = state.getValue(BlockDrawers.FACING);

        if (!(state instanceof IExtendedBlockState))
            return parent;

        IExtendedBlockState xstate = (IExtendedBlockState)state;
        DrawerStateModelData stateModel = xstate.getValue(BlockDrawers.STATE_MODEL);

        if (!DrawerDecoratorModel.shouldHandleState(stateModel))
            return parent;

        return new DrawerDecoratorModel(parent, xstate, drawer, dir, stateModel);
    }
    catch (Throwable t) {
        return parent;
    }
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    if (state instanceof IExtendedBlockState) {  // avoid crash in case of mismatch
        IExtendedBlockState retval = (IExtendedBlockState) state;
        boolean linkup = canConnectTo(world, pos, EnumFacing.UP, pos.up());
        retval = retval.withProperty(LINK_UP, linkup);

        boolean linkdown = canConnectTo(world, pos, EnumFacing.DOWN, pos.down());
        retval = retval.withProperty(LINK_DOWN, linkdown);

        boolean linkeast = canConnectTo(world, pos, EnumFacing.EAST, pos.east());
        retval = retval.withProperty(LINK_EAST, linkeast);

        boolean linkwest = canConnectTo(world, pos, EnumFacing.WEST, pos.west());
        retval = retval.withProperty(LINK_WEST, linkwest);

        boolean linknorth = canConnectTo(world, pos, EnumFacing.NORTH, pos.north());
        retval = retval.withProperty(LINK_NORTH, linknorth);

        boolean linksouth = canConnectTo(world, pos, EnumFacing.NORTH, pos.south());
        retval = retval.withProperty(LINK_SOUTH, linksouth);

        return retval;
    }
    return state;
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    if (state instanceof IExtendedBlockState) {
        IExtendedBlockState extendedBlockState = (IExtendedBlockState)state;
        TileEntityMarker te = (TileEntityMarker)world.getTileEntity(pos);
        boolean north = te.isFaceEnabled(EnumFacing.NORTH);
        boolean south = te.isFaceEnabled(EnumFacing.SOUTH);
        boolean east = te.isFaceEnabled(EnumFacing.EAST);
        boolean west = te.isFaceEnabled(EnumFacing.WEST);
        boolean up = te.isFaceEnabled(EnumFacing.UP);
        boolean down = te.isFaceEnabled(EnumFacing.DOWN);
        EnumFacing f = te.getFacing();

        return extendedBlockState
                .withProperty(NORTH, north)
                .withProperty(SOUTH, south)
                .withProperty(EAST, east)
                .withProperty(WEST, west)
                .withProperty(UP, up)
                .withProperty(DOWN, down)
                .withProperty(FACING, f.ordinal());
    }

    return state;
}

@Override
public void renderWorldBlockStatic(ITessellator tessellator, IBlockState state, BlockWaterPad block, EnumFacing side) {
    // Icon
    final TextureAtlasSprite matIcon = BaseIcons.DIRT.getIcon();
    final TextureAtlasSprite waterIcon = BaseIcons.WATER_STILL.getIcon();

    // Check Full
    SidedConnection connection = state instanceof IExtendedBlockState ? ((IExtendedBlockState) state).getValue(AgriProperties.CONNECTIONS) : DEFAULT;

    // Draw Base
    renderBase(tessellator, matIcon);

    // Render Sides
    for (EnumFacing dir : EnumFacing.HORIZONTALS) {
        if (!connection.isConnected(dir)) {
            renderSide(tessellator, dir, matIcon);
        }
    }

    // Render Water
    if (AgriProperties.POWERED.getValue(state)) {
        renderWater(tessellator, waterIcon);
    }
}

@Override
protected void renderWorldBlockWoodStatic(ITessellator tess, IExtendedBlockState state, BlockGrate block, EnumFacing side, TextureAtlasSprite sprite) {
    // Setup
    final float offset = AgriProperties.OFFSET.getValue(state).getOffset();

    // Offset
    tess.translate(0, 0, offset);

    // Draw Grate
    tess.drawScaledPrism(1, 0, 0, 3, 16, 2, sprite);
    tess.drawScaledPrism(5, 0, 0, 7, 16, 2, sprite);
    tess.drawScaledPrism(9, 0, 0, 11, 16, 2, sprite);
    tess.drawScaledPrism(13, 0, 0, 15, 16, 2, sprite);
    tess.drawScaledPrism(0, 1, 0, 16, 3, 2, sprite);
    tess.drawScaledPrism(0, 5, 0, 16, 7, 2, sprite);
    tess.drawScaledPrism(0, 9, 0, 16, 11, 2, sprite);
    tess.drawScaledPrism(0, 13, 0, 16, 15, 2, sprite);

}

@Override
public void renderWorldBlockStatic(ITessellator tessellator, IBlockState state, BlockCrop block, EnumFacing side) {
    TextureAtlasSprite sprite = RenderCrop.getIcon(TEXTURE);
    this.renderBaseQuads(tessellator, side, sprite);
    if (state instanceof IExtendedBlockState) {
        IExtendedBlockState extendedState = (IExtendedBlockState) state;
        IAgriPlant plant = extendedState.getValue(AgriProperties.CROP_PLANT);
        int growthstage = extendedState.getValue(AgriProperties.GROWTH_STAGE);
        if (extendedState.getValue(AgriProperties.CROSS_CROP)) {
            tessellator.drawScaledPrism(0, 10, 2, 16, 11, 3, sprite);
            tessellator.drawScaledPrism(0, 10, 13, 16, 11, 14, sprite);
            tessellator.drawScaledPrism(2, 10, 0, 3, 11, 16, sprite);
            tessellator.drawScaledPrism(13, 10, 0, 14, 11, 16, sprite);
        }
        if (plant != null) {
            tessellator.addQuads(plant.getPlantQuads(extendedState, growthstage, side, tessellator));
        }
    }
}

@Override
public IBlockState getExtendedState(IBlockState oldState, IBlockAccess world, BlockPos pos)
{
    if (this.isCamoBlock())
    {
        TileEntityEnderUtilities te = getTileEntitySafely(world, pos, TileEntityEnderUtilities.class);

        if (te != null)
        {
            IExtendedBlockState state = (IExtendedBlockState) oldState;
            state = state.withProperty(CAMOBLOCKSTATE, te.getCamoState());
            state = state.withProperty(CAMOBLOCKSTATEEXTENDED, te.getCamoExtendedState());
            return state;
        }
    }

    return oldState;
}

@SuppressWarnings("deprecation")
@Override
public int getLightValue(IBlockState state, IBlockAccess world, BlockPos pos)
{
    if (this.isCamoBlock())
    {
        IExtendedBlockState extendedState = (IExtendedBlockState) this.getExtendedState(state.getActualState(world, pos), world, pos);
        IBlockState stateCamo = extendedState.getValue(CAMOBLOCKSTATE);

        if (stateCamo != null)
        {
            // Can't call this same world sensitive method here, because it might/will recurse back here!
            return stateCamo.getLightValue();
        }
    }

    return super.getLightValue(state, world, pos);
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    IExtendedBlockState extendedState = (IExtendedBlockState)state;
    TileEntity tileEntity = world.getTileEntity(pos);
    if (tileEntity != null && tileEntity instanceof TileEntityMachineBase) {

        int front = ((TileEntityMachineBase)tileEntity).facing;
        extendedState = extendedState.withProperty(hiddenProperties[0], front);
        int operating = 0;
        if (((TileEntityMachineBase)tileEntity).ticksLeft != 0) {
            operating = 1;
        }
        extendedState = extendedState.withProperty(hiddenProperties[1], operating);
    }
    return extendedState;
}

@Override
public List<BakedQuad> getQuads(IBlockState blockState, EnumFacing side, long rand)
{
    if (side != null) return ImmutableList.of();
    if (quads == null)
    {
        quads = buildQuads(this.state);
    }
    if (blockState instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState) blockState;
        if (exState.getUnlistedNames().contains(net.minecraftforge.common.property.Properties.AnimationProperty))
        {

            IModelState newState = exState.getValue(net.minecraftforge.common.property.Properties.AnimationProperty);
            if (newState != null)
            {
                newState = new ModelStateComposition(this.state, newState);
                return buildQuads(newState);
            }
        }
    }
    return quads;
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
    final Optional<IBlockState> maybeInnerBlock;
    final Optional<CanvasState> maybeCanvasState;
    if (state instanceof IExtendedBlockState) {
        final IExtendedBlockState extendedState = (IExtendedBlockState)state;
        final ImmutableMap<IUnlistedProperty<?>, Optional<?>> unlistedProperties = extendedState.getUnlistedProperties();
        maybeInnerBlock = getProperty(unlistedProperties, InnerBlockState.PROPERTY);
        maybeCanvasState = getProperty(unlistedProperties, CanvasState.PROPERTY);

        if (maybeCanvasState.isPresent()) maybeCanvasState.get().onRender();
    } else {
        maybeInnerBlock = Optional.empty();
        maybeCanvasState = Optional.empty();
    }

    final BlockRenderLayer renderLayer = MoreObjects.firstNonNull(MinecraftForgeClient.getRenderLayer(), BlockRenderLayer.CUTOUT);

    return modelTransformer.getQuads(maybeInnerBlock, maybeCanvasState, renderLayer).get(side);

}

@Override
public void renderTileEntityFast(TileEntityFan te, double x, double y, double z, float partialTicks, int destroyStage, float alpha, BufferBuilder renderer) {
    if (blockRenderer == null) blockRenderer = Minecraft.getMinecraft().getBlockRendererDispatcher();

    final BlockPos pos = te.getPos();
    final IBlockAccess world = MinecraftForgeClient.getRegionRenderCache(te.getWorld(), pos);
    IBlockState state = world.getBlockState(pos);

    if (state.getPropertyKeys().contains(Properties.StaticProperty)) {
        state = state.withProperty(Properties.StaticProperty, false);
    }

    if (state instanceof IExtendedBlockState) {
        state = state.getBlock().getExtendedState(state, world, pos);

        IExtendedBlockState exState = ((IExtendedBlockState)state).withProperty(EvalModelState.PROPERTY, te.getTesrRenderState(partialTicks));
        final IBakedModel model = blockRenderer.getBlockModelShapes().getModelForState(exState.getClean());
        renderer.setTranslation(x - pos.getX(), y - pos.getY(), z - pos.getZ());
        blockRenderer.getBlockModelRenderer().renderModel(world, model, exState, pos, renderer, false);
        renderer.setTranslation(0, 0, 0);
    }
}

@Override
public void renderTileEntityFast(TileEntityBearTrap te, double x, double y, double z, float partialTicks, int destroyStage, float alpha, BufferBuilder renderer) {
    if (blockRenderer == null) blockRenderer = Minecraft.getMinecraft().getBlockRendererDispatcher();

    final BlockPos pos = te.getPos();
    final IBlockAccess world = MinecraftForgeClient.getRegionRenderCache(te.getWorld(), pos);
    IBlockState state = world.getBlockState(pos);

    if (state instanceof IExtendedBlockState) {
        state = state.getBlock().getExtendedState(state, world, pos);

        IExtendedBlockState exState = ((IExtendedBlockState)state).withProperty(EvalModelState.PROPERTY, te.getRenderState(partialTicks));
        final IBakedModel model = blockRenderer.getBlockModelShapes().getModelForState(exState.getClean());
        renderer.setTranslation(x - pos.getX(), y - pos.getY(), z - pos.getZ());
        blockRenderer.getBlockModelRenderer().renderModel(world, model, exState, pos, renderer, false);
        renderer.setTranslation(0, 0, 0);
    }
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    if (state instanceof IExtendedBlockState) {
        final TileEntityPaintMixer mixer = getTileEntity(world, pos, TileEntityPaintMixer.class);
        if (mixer != null) {
            final int progress = mixer.getProgress().getValue();

            final int currentColor;

            if (progress != 0) {
                final RGB startColor = new RGB(mixer.getCanColor());
                final RGB endColor = new RGB(mixer.getColor().getValue());
                final float scaledProgress = progress / (float)TileEntityPaintMixer.PROGRESS_TICKS;
                currentColor = startColor.interpolate(endColor, scaledProgress).getColor();
            } else {
                currentColor = mixer.getCanColor();
            }
            return ((IExtendedBlockState)state).withProperty(CAN_COLOR, currentColor);
        }
    }

    return state;
}

@Override
public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
    final IModel model = loadBaseModel(state, format, bakedTextureGetter);

    IBlockState blockState = null;

    if (defaultBlockState.isPresent()) {
        final Block defaultBlock = Block.REGISTRY.getObject(defaultBlockState.get());
        if (defaultBlock != Blocks.AIR) {
            blockState = defaultBlock.getDefaultState();
            if (!(blockState instanceof IExtendedBlockState) ||
                    !((IExtendedBlockState)blockState).getUnlistedNames().contains(EvalModelState.PROPERTY)) {
                Log.warn("State %s does not contain eval state property", blockState);
            }
        } else {
            Log.warn("Can't find default block: %s", defaultBlockState.get());
        }
    }

    final IVarExpander expander = evaluatorFactory.createExpander();
    return new BakedEvalExpandModel(model, state, format, bakedTextureGetter, blockState, expander);
}

private IBakedModel handleBlockState(IBlockState state) {
    if (state instanceof IExtendedBlockState) {
        IExtendedBlockState ext = (IExtendedBlockState) state;
        IBlockState camoState = ext.getValue(BlockPneumaticCraftCamo.CAMO_STATE);
        if (camoState != null && !(camoState.getBlock() instanceof BlockPneumaticCraftCamo)) {
            BlockModelShapes blockModelShapes = Minecraft.getMinecraft().getBlockRendererDispatcher().getBlockModelShapes();
            return blockModelShapes.getModelForState(camoState);
        }
    }

    return originalModel;
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    IExtendedBlockState extendedBlockState = (IExtendedBlockState) state;

    return extendedBlockState
            .withProperty(DOWN, getTextureIndex(world, pos, EnumFacing.DOWN))
            .withProperty(UP, getTextureIndex(world, pos, EnumFacing.UP))
            .withProperty(NORTH, getTextureIndex(world, pos, EnumFacing.NORTH))
            .withProperty(SOUTH, getTextureIndex(world, pos, EnumFacing.SOUTH))
            .withProperty(WEST, getTextureIndex(world, pos, EnumFacing.WEST))
            .withProperty(EAST, getTextureIndex(world, pos, EnumFacing.EAST));
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    TileEntity te = PneumaticCraftUtils.getTileEntitySafely(world, pos);
    if (te instanceof ICamouflageableTE) {
        IBlockState camoState = ((ICamouflageableTE) te).getCamouflage();
        if (camoState != null) {
            return ((IExtendedBlockState) state).withProperty(CAMO_STATE, camoState);
        }
    }
    return state;
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
    if (state instanceof IExtendedBlockState) {
        List<IBakedModel> subModels = getSubModels((IExtendedBlockState) state);
        List<BakedQuad> quads = new ArrayList<BakedQuad>();

        for (IBakedModel model : subModels) {
            quads.addAll(model.getQuads(state, side, rand));
        }

        return quads;
    }
    return Collections.EMPTY_LIST;
}

@Override
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess world, BlockPos pos) {
    IExtendedBlockState extendedState = (IExtendedBlockState) getExtendedState(state, world, pos);

    double min = 0.3125, max = 0.6875;

    double x1 = min, y1 = min, z1 = min;
    double x2 = max, y2 = max, z2 = max;
    if (extendedState.getValue(CONNECTIONS[0]) > 0) {
        y1 = 0;
    }
    if (extendedState.getValue(CONNECTIONS[1]) > 0) {
        y2 = 1;
    }
    if (extendedState.getValue(CONNECTIONS[2]) > 0) {
        z1 = 0;
    }
    if (extendedState.getValue(CONNECTIONS[3]) > 0) {
        z2 = 1;
    }
    if (extendedState.getValue(CONNECTIONS[4]) > 0) {
        x1 = 0;
    }
    if (extendedState.getValue(CONNECTIONS[5]) > 0) {
        x2 = 1;
    }

    return new AxisAlignedBB(x1, y1, z1, x2, y2, z2);
}

@Override
public void addCollisionBoxToList(IBlockState state, World worldIn, BlockPos pos, AxisAlignedBB entityBox,
        List<AxisAlignedBB> collidingBoxes, @Nullable Entity entityIn, boolean p_185477_7_) {
    addCollisionBoxToList(pos, entityBox, collidingBoxes, NODE_AABB);
    IExtendedBlockState extendedState = (IExtendedBlockState) getExtendedState(state, worldIn, pos);

    for (int i = 0; i < CONNECTIONS.length; i++) {
        if (extendedState.getValue(CONNECTIONS[i]) > 0) {
            addCollisionBoxToList(pos, entityBox, collidingBoxes, CONNECTION_AABB[i]);
        }
    }

}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
    IExtendedBlockState extendedState = (IExtendedBlockState) state;
    for (int i = 0; i < CONNECTIONS.length; i++) {
        int connected = getConnection(world, pos, EnumFacing.getFront(i));
        extendedState = extendedState.withProperty(CONNECTIONS[i], connected);
    }
    return extendedState;
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos)
{
    if (state instanceof IExtendedBlockState)
    {
        TileEntity te = world.getTileEntity(pos);
        if (te != null && te instanceof TileWallIfTablet)
        {
            return ((IExtendedBlockState) state).withProperty(IF_TIER, ((TileWallIfTablet) te).getTier());
        }
    }
    return state;
}

@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos)
{
    if(state instanceof IExtendedBlockState)
    {
        TileEntity te = world.getTileEntity(pos);
        if(te != null && te instanceof TileCodeStorage)
        {
            return ((IExtendedBlockState) state).withProperty(UNLOCKED_PROPERTY, ((TileCodeStorage) te).isUnlocked());
        }
    }
    return super.getExtendedState(state, world, pos);
}

public void renderTileEntityFast(T te, double x, double y, double z, float partialTick, int breakStage, VertexBuffer renderer)
{
    if(!te.hasCapability(CapabilityAnimation.ANIMATION_CAPABILITY, null))
    {
        return;
    }
    if(blockRenderer == null) blockRenderer = Minecraft.getMinecraft().getBlockRendererDispatcher();
    BlockPos pos = te.getPos();
    IBlockAccess world = MinecraftForgeClient.getRegionRenderCache(te.getWorld(), pos);
    IBlockState state = world.getBlockState(pos);
    if(state.getPropertyNames().contains(Properties.StaticProperty))
    {
        state = state.withProperty(Properties.StaticProperty, false);
    }
    if(state instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState)state;
        if(exState.getUnlistedNames().contains(Properties.AnimationProperty))
        {
            float time = Animation.getWorldTime(getWorld(), partialTick);
            Pair<IModelState, Iterable<Event>> pair = te.getCapability(CapabilityAnimation.ANIMATION_CAPABILITY, null).apply(time);
            handleEvents(te, time, pair.getRight());

            // TODO: caching?
            IBakedModel model = blockRenderer.getBlockModelShapes().getModelForState(exState.getClean());
            exState = exState.withProperty(Properties.AnimationProperty, pair.getLeft());

            renderer.setTranslation(x - pos.getX(), y - pos.getY(), z - pos.getZ());

            blockRenderer.getBlockModelRenderer().renderModel(world, model, exState, pos, renderer, false);
        }
    }
}

private static int[] getCorners(Optional<IExtendedBlockState> stateOption)
{
    int[] cornerRound = new int[]{0, 0, 0, 0};
    if(stateOption.isPresent())
    {
        IExtendedBlockState state = stateOption.get();
        for(int i = 0; i < 4; i++)
        {
            Float level = state.getValue(BlockFluidBase.LEVEL_CORNERS[i]);
            cornerRound[i] = Math.round((level == null ? 7f / 8 : level) * 768);
        }
    }
    return cornerRound;
}

private static int getFlow(Optional<IExtendedBlockState> stateOption)
{
    Float flow = -1000f;
    if(stateOption.isPresent())
    {
        flow = stateOption.get().getValue(BlockFluidBase.FLOW_DIRECTION);
        if(flow == null) flow = -1000f;
    }
    int flowRound = (int)Math.round(Math.toDegrees(flow));
    flowRound = MathHelper.clamp_int(flowRound, -1000, 1000);
    return flowRound;
}