Java Code Examples for net.minecraft.util.EnumFacing#Axis

/**
 * Sets the freshly placed TileEntityGrate's orientation.
 *
 * @param grate the grate in question.
 * @param hitX the hit x-coordinate.
 * @param hitY the hit y-coordinate.
 * @param hitZ the hit z-coordinate.
 * @param axis the axis the block is on.
 */
private static void setOffsetOrientation(TileEntityGrate grate, float hitX, float hitY, float hitZ, EnumFacing.Axis axis) {
    // Set the grate's axis.
    grate.setAxis(axis);

    // Resolve the hit value.
    final float hit = getAxialValue(axis, hitX, hitY, hitZ);

    // Set the grate's offset.
    if (hit <= 0.3333F) {
        grate.setOffset(TileEntityGrate.EnumOffset.NEAR);
    } else if (hit <= 0.6666F) {
        grate.setOffset(TileEntityGrate.EnumOffset.CENTER);
    } else {
        grate.setOffset(TileEntityGrate.EnumOffset.FAR);
    }
}
 

@Override
protected void renderWorldBlockWoodStatic(ITessellator tess, IExtendedBlockState state, BlockGrate block, EnumFacing side, TextureAtlasSprite sprite) {
    // Setup
    final TileEntityGrate.EnumOffset offset = AgriProperties.OFFSET.getValue(state);
    final EnumFacing.Axis axis = AgriProperties.AXIS.getValue(state);
    
    // Rotate
    RenderUtilBase.rotateBlock(tess, EnumFacing.getFacingFromAxis(EnumFacing.AxisDirection.POSITIVE, axis));

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

    // 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);

}
 

@SideOnly(Side.CLIENT)
public static PropertyItem.PItem getDisplayItem(ItemStack stack, World world, EntityLivingBase entity, float x, float z, EnumFacing.Axis axis) {
	if(stack == null)
		return null;

	IBakedModel model = Minecraft.getMinecraft().getRenderItem().getItemModelWithOverrides(stack, world, entity);
	if(model == null || model.isBuiltInRenderer()) {
		// missing model so people don't go paranoid when their chests go missing
		model = Minecraft.getMinecraft().getRenderItem().getItemModelMesher().getModelManager().getMissingModel();
	}
	float rotation = 0;
	if(axis == EnumFacing.Axis.X)
	{
		rotation = (float)Math.PI /2f;
	}
	PropertyItem.PItem item = new PropertyItem.PItem(model, x,0,z, 0.45f, axis == EnumFacing.Axis.X ? (float) (Math.PI/2f) : 0);
	if(stack.getItem() instanceof ItemBlock) {
		item.y = -0.3125f;
		item.s = 0.375f;
		item.r = 0;
	}
	return item;
}
 

@SubscribeEvent
public static void onLivingUpdate(LivingEvent.LivingUpdateEvent event) {
    EntityLivingBase entity = event.getEntityLiving();
    if (entity.world.isRemote) {
        return;
    }

    if (entity.collidedHorizontally && isBeingPushedByPiston(entity)) {
        Squashable squashable = entity.getCapability(squashableCap(), null);
        if (squashable == null) {
            return;
        }

        double[] pistonDeltas = getPistonDeltas(entity);
        double pushedAngle = Math.atan2(pistonDeltas[2], pistonDeltas[0]);

        EnumFacing.Axis faceAxis = EnumFacing.fromAngle(entity.rotationYaw).getAxis();
        EnumFacing.Axis pushAxis = EnumFacing.fromAngle(pushedAngle).getAxis();

        EnumFacing.Axis squashAxis = faceAxis == pushAxis ? EnumFacing.Axis.Z : EnumFacing.Axis.X;

        squashable.squash(squashAxis);

        NETWORK.sendToAllTracking(new SquashEntityMessage(entity, squashAxis), entity);
    }
}
 

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos)
{
    EnumFacing.Axis enumfacing$axis = state.getValue(FACING).getAxis();

    if (enumfacing$axis == EnumFacing.Axis.Z && (canFenceGateConnectTo(worldIn, pos, EnumFacing.WEST) || canFenceGateConnectTo(worldIn, pos, EnumFacing.EAST)) || enumfacing$axis == EnumFacing.Axis.X && (canFenceGateConnectTo(worldIn, pos, EnumFacing.NORTH) || canFenceGateConnectTo(worldIn, pos, EnumFacing.SOUTH)))
    {
        state = state.withProperty(IN_WALL, Boolean.TRUE);
    }

    return state;
}
 

protected void countBlocksInChunkRespectingLayerRange(ChunkPos pos, LayerRange range)
{
    EnumFacing.Axis axis = range.getAxis();
    BlockPos.MutableBlockPos posMutable = new BlockPos.MutableBlockPos();

    for (IntBoundingBox bb : this.getBoxesInChunk(pos))
    {
        final int startX = axis == EnumFacing.Axis.X ? Math.max(bb.minX, range.getLayerMin()) : bb.minX;
        final int startY = axis == EnumFacing.Axis.Y ? Math.max(bb.minY, range.getLayerMin()) : bb.minY;
        final int startZ = axis == EnumFacing.Axis.Z ? Math.max(bb.minZ, range.getLayerMin()) : bb.minZ;
        final int endX = axis == EnumFacing.Axis.X ? Math.min(bb.maxX, range.getLayerMax()) : bb.maxX;
        final int endY = axis == EnumFacing.Axis.Y ? Math.min(bb.maxY, range.getLayerMax()) : bb.maxY;
        final int endZ = axis == EnumFacing.Axis.Z ? Math.min(bb.maxZ, range.getLayerMax()) : bb.maxZ;

        for (int y = startY; y <= endY; ++y)
        {
            for (int z = startZ; z <= endZ; ++z)
            {
                for (int x = startX; x <= endX; ++x)
                {
                    posMutable.setPos(x, y, z);
                    this.countAtPosition(posMutable);
                }
            }
        }
    }
}
 

private static float getAxialValue(@Nonnull EnumFacing.Axis axis, float x, float y, float z) {
    switch (axis) {
        case X:
            return x;
        case Y:
            return y;
        case Z:
            return z;
        default:
            throw new NullPointerException();
    }
}
 

public void setAxis(@Nonnull EnumFacing.Axis axis) {
    // Validate.
    Preconditions.checkNotNull(axis);

    // Set.
    if (this.axis != axis) {
        this.axis = axis;
        this.markForUpdate();
    }
}
 

@Override
public void fromBytes(ByteBuf buf) {
    this.entityId = buf.readInt();

    EnumFacing.Axis[] values = EnumFacing.Axis.values();
    this.axis = values[buf.readByte() % values.length];
}
 

public static EnumAxis fromFacingAxis(EnumFacing.Axis axis)
{
    switch (axis)
    {
        case X:
            return X;
        case Y:
            return Y;
        case Z:
            return Z;
        default:
            return NONE;
    }
}
 

public static EnumFacing[] getSidesForAxis(EnumFacing.Axis axis)
{
    if (axis == EnumFacing.Axis.X)
    {
        return ADJACENT_SIDES_ZY;
    }

    return axis == EnumFacing.Axis.Z ? ADJACENT_SIDES_XY : ADJACENT_SIDES_XZ;
}
 

@Override
public void render(TileEntityRotationAxle tileentity, double x, double y, double z,
    float partialTick, int destroyStage, float alpha) {
    this.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
    GlStateManager.pushMatrix();
    GlStateManager.disableLighting();

    GlStateManager.translate(x, y, z);
    GlStateManager.disableAlpha();
    GlStateManager.disableBlend();

    int brightness = tileentity.getWorld().getCombinedLight(tileentity.getPos(), 0);
    IBlockState gearState = Minecraft.getMinecraft().world.getBlockState(tileentity.getPos());
    if (gearState.getBlock() instanceof BlockRotationAxle) {
        EnumFacing.Axis facingAxis = gearState.getValue(BlockRotationAxle.AXIS);

        GlStateManager.translate(0.5, 0.5, 0.5);
        switch (facingAxis) {
            case X:
                // Rotates (1, 0, 0) -> (1, 0, 0)
                break;
            case Y:
                // Rotates (1, 0, 0) -> (0, 1, 0)
                GL11.glRotated(90, 0, 0, 1);
                break;
            case Z:
                // Rotates (1, 0, 0) -> (0, 0, 1)
                GL11.glRotated(-90, 0, 1, 0);
                break;
        }
        GL11.glRotated(Math.toDegrees(tileentity.getRenderRotationRadians(partialTick)), 1, 0,
            0);
        GlStateManager.translate(-0.5, -0.5, -0.5);
    }

    double keyframe = 1;
    GibsAnimationRegistry.getAnimation("rotation_axle")
        .renderAnimation(keyframe, brightness);

    GlStateManager.popMatrix();
    GlStateManager.enableLighting();
    GlStateManager.resetColor();
}
 

public void setRotation(EnumFacing.Axis axis)
{
	rotation = axis;
}
 

public FlattenedModel(ModelBase wrapped, EnumFacing.Axis squashedAxis) {
    this.wrapped = wrapped;
    this.squashedAxis = squashedAxis;
}
 

@Nullable
public EnumFacing.Axis getSquashedAxis() {
    return this.squashedAxis;
}
 

public TileEntityRotationAxle(EnumFacing.Axis axleAxis) {
    super();
    setAxleAxis(axleAxis);
}
 

protected void renderOverlayReducedEdges(BlockPos pos, OverlayType[][][] adjTypes, OverlayType typeSelf, Color4f overlayColor, BufferBuilder bufferOverlayOutlines)
{
    OverlayType[] neighborTypes = new OverlayType[4];
    Vec3i[] neighborPositions = new Vec3i[4];
    int lines = 0;

    for (EnumFacing.Axis axis : PositionUtils.AXES_ALL)
    {
        for (int corner = 0; corner < 4; ++corner)
        {
            Vec3i[] offsets = PositionUtils.getEdgeNeighborOffsets(axis, corner);
            int index = -1;
            boolean hasCurrent = false;

            // Find the position(s) around a given edge line that have the shared greatest rendering priority
            for (int i = 0; i < 4; ++i)
            {
                Vec3i offset = offsets[i];
                OverlayType type = adjTypes[offset.getX() + 1][offset.getY() + 1][offset.getZ() + 1];

                // type NONE
                if (type == OverlayType.NONE)
                {
                    continue;
                }

                // First entry, or sharing at least the current highest found priority
                if (index == -1 || type.getRenderPriority() >= neighborTypes[index - 1].getRenderPriority())
                {
                    // Actually a new highest priority, add it as the first entry and rewind the index
                    if (index < 0 || type.getRenderPriority() > neighborTypes[index - 1].getRenderPriority())
                    {
                        index = 0;
                    }
                    // else: Same priority as a previous entry, append this position

                    //System.out.printf("plop 0 axis: %s, corner: %d, i: %d, index: %d, type: %s\n", axis, corner, i, index, type);
                    neighborPositions[index] = new Vec3i(pos.getX() + offset.getX(), pos.getY() + offset.getY(), pos.getZ() + offset.getZ());
                    neighborTypes[index] = type;
                    // The self position is the first (offset = [0, 0, 0]) in the arrays
                    hasCurrent |= (i == 0);
                    ++index;
                }
            }

            //System.out.printf("plop 1 index: %d, pos: %s\n", index, pos);
            // Found something to render, and the current block is among the highest priority for this edge
            if (index > 0 && hasCurrent)
            {
                Vec3i posTmp = new Vec3i(pos.getX(), pos.getY(), pos.getZ());
                int ind = -1;

                for (int i = 0; i < index; ++i)
                {
                    Vec3i tmp = neighborPositions[i];
                    //System.out.printf("posTmp: %s, tmp: %s\n", posTmp, tmp);

                    // Just prioritize the position to render a shared highest priority edge by the coordinates
                    if (tmp.getX() <= posTmp.getX() && tmp.getY() <= posTmp.getY() && tmp.getZ() <= posTmp.getZ())
                    {
                        posTmp = tmp;
                        ind = i;
                    }
                }

                // The current position is the one that should render this edge
                if (posTmp.getX() == pos.getX() && posTmp.getY() == pos.getY() && posTmp.getZ() == pos.getZ())
                {
                    //System.out.printf("plop 2 index: %d, ind: %d, pos: %s, off: %s\n", index, ind, pos, posTmp);
                    RenderUtils.drawBlockBoxEdgeBatchedLines(pos, axis, corner, overlayColor, bufferOverlayOutlines);
                    lines++;
                }
            }
        }
    }
    //System.out.printf("typeSelf: %s, pos: %s, lines: %d\n", typeSelf, pos, lines);
}
 

private boolean walkFrameLoop(BlockPos pos, EnumFacing.Axis axis, EnumFacing frameSide, int distanceLimit)
{
    int counter = 0;
    int turns = 0;
    int tries = 0;
    IBlockState state;
    Block block;
    BlockPos startPos = pos;
    BlockPos posLast = startPos;
    EnumFacing firstTrySide = frameSide;
    EnumFacing moveDirection = frameSide;

    while (counter < distanceLimit)
    {
        moveDirection = firstTrySide;

        for (tries = 0; tries < 4; tries++)
        {
            pos = posLast.offset(moveDirection);
            state = this.world.getBlockState(pos);
            block = state.getBlock();

            if (block.isAir(state, this.world, pos))
            {
                posLast = pos;

                // The firstTrySide is facing into the adjacent portal frame when traveling
                // along a straight frame. Thus we need to rotate it once to keep going straight.
                // If we need to rotate it more than once, then we have hit a "right hand corner".
                if (tries > 1)
                {
                    turns++;
                }
                // If we didn't have to rotate the firstTrySide at all, then we hit a "left hand turn"
                // ie. traveled through an outer bend.
                else if (tries == 0)
                {
                    turns--;
                }

                // Set the firstTrySide one rotation back from the side that we successfully moved to
                // so that we can go around possible outer bends.
                firstTrySide = moveDirection.rotateAround(axis).getOpposite();

                break;
            }
            // Found a portal frame block, try the next adjacent side...
            else if (block == this.blockFrame)
            {
                moveDirection = moveDirection.rotateAround(axis);
            }
            // Found a non-air, non-portal-frame block -> invalid area.
            else
            {
                return false;
            }
        }

        // If we can return to the starting position hugging the portal frame,
        // then this is a valid portal frame loop.
        // Note that it is only valid if it forms an inside area, thus the turns check.
        // the tries == 4 && counter == 0 check is for a 1x1 area special case
        if ((tries == 4 && counter == 0) || pos.equals(startPos))
        {
            return turns >= 0;
        }

        counter++;
    }

    return false;
}
 

public EnumFacing.Axis getRotation() {
	return rotation;
}
 

@Override
public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) {

    EnumFacing.Axis enumfacing$axis = state.getValue(AXIS);


    if (enumfacing$axis == EnumFacing.Axis.X) {

        Size blockportal$size = new Size(worldIn, pos, EnumFacing.Axis.X);


        if (!blockportal$size.isValid() ||

                blockportal$size.portalBlockCount < blockportal$size.width * blockportal$size.height) {

            worldIn.setBlockState(pos, Blocks.AIR.getDefaultState());

        }

    } else if (enumfacing$axis == EnumFacing.Axis.Z) {

        Size blockportal$size1 = new Size(worldIn, pos, EnumFacing.Axis.Z);


        if (!blockportal$size1.isValid() ||

                blockportal$size1.portalBlockCount < blockportal$size1.width * blockportal$size1.height) {

            worldIn.setBlockState(pos, Blocks.AIR.getDefaultState());

        }

    }

}