Java Vec3i.getX方法代碼示例

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
@Override
protected void onWorldDraw(float delta, float x, float y, float z) {
    float mx, my, mz;
    if (!safeShow) return;
    if (--safeUpdate < 0) {
        safeUpdate = 13;
        reCheckSafe(fix(x), fix(y), fix(z));
    }
    if (safeGhost) GL11.glDisable(GL11.GL_DEPTH_TEST);
    else           GL11.glEnable( GL11.GL_DEPTH_TEST);
    GL11.glDisable(GL11.GL_TEXTURE_2D);
    GL11.glDisable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_FOG);
    GL11.glBegin(GL11.GL_LINES);
    for (int i = 0; i < safeCur; ++i) {
        Vec3i pos   = safePoses[i];
        Color color = safeMarks[i];
        GL11.glColor3ub(color.rb, color.gb, color.bb);
        mx = pos.getX() - x; my = pos.getY() - y; mz = pos.getZ() - z;
        GL11.glVertex3f(mx+0.9f,my+0.01f,mz+0.9f);
        GL11.glVertex3f(mx+0.1f,my+0.01f,mz+0.1f);
        GL11.glVertex3f(mx+0.9f,my+0.01f,mz+0.1f);
        GL11.glVertex3f(mx+0.1f,my+0.01f,mz+0.9f);
    }
    GL11.glEnd();
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
/** 
 * Rotates given surface vector around the center of the texture by the given degree.
 * 
 */
protected static Vec3i rotateFacePerspective(Vec3i vec, Rotation rotation, TextureScale scale)
{
    switch(rotation)
    {
    case ROTATE_90:
        return new Vec3i(vec.getY(), scale.sliceCountMask - vec.getX(), vec.getZ());

    case ROTATE_180:
        return new Vec3i(scale.sliceCountMask - vec.getX(), scale.sliceCountMask - vec.getY(), vec.getZ());
        
    case ROTATE_270:
        return new Vec3i(scale.sliceCountMask - vec.getY(), vec.getX(), vec.getZ());

    case ROTATE_NONE:
    default:
        return vec;
    
    }
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
public static EnumFacing rotate(Matrix4f matrix, EnumFacing facing)
{
    Vec3i dir = facing.getDirectionVec();
    Vector4f vec = new Vector4f(dir.getX(), dir.getY(), dir.getZ(), 0);
    matrix.transform(vec);
    return EnumFacing.getFacingFromVector(vec.x, vec.y, vec.z);
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
public static EnumFacing getFacingFromVertexData(int[] faceData)
{
    Vector3f vector3f = new Vector3f(Float.intBitsToFloat(faceData[0]), Float.intBitsToFloat(faceData[1]), Float.intBitsToFloat(faceData[2]));
    Vector3f vector3f1 = new Vector3f(Float.intBitsToFloat(faceData[7]), Float.intBitsToFloat(faceData[8]), Float.intBitsToFloat(faceData[9]));
    Vector3f vector3f2 = new Vector3f(Float.intBitsToFloat(faceData[14]), Float.intBitsToFloat(faceData[15]), Float.intBitsToFloat(faceData[16]));
    Vector3f vector3f3 = new Vector3f();
    Vector3f vector3f4 = new Vector3f();
    Vector3f vector3f5 = new Vector3f();
    Vector3f.sub(vector3f, vector3f1, vector3f3);
    Vector3f.sub(vector3f2, vector3f1, vector3f4);
    Vector3f.cross(vector3f4, vector3f3, vector3f5);
    float f = (float)Math.sqrt((double)(vector3f5.x * vector3f5.x + vector3f5.y * vector3f5.y + vector3f5.z * vector3f5.z));
    vector3f5.x /= f;
    vector3f5.y /= f;
    vector3f5.z /= f;
    EnumFacing enumfacing = null;
    float f1 = 0.0F;

    for (EnumFacing enumfacing1 : EnumFacing.values())
    {
        Vec3i vec3i = enumfacing1.getDirectionVec();
        Vector3f vector3f6 = new Vector3f((float)vec3i.getX(), (float)vec3i.getY(), (float)vec3i.getZ());
        float f2 = Vector3f.dot(vector3f5, vector3f6);

        if (f2 >= 0.0F && f2 > f1)
        {
            f1 = f2;
            enumfacing = enumfacing1;
        }
    }

    if (enumfacing == null)
    {
        return EnumFacing.UP;
    }
    else
    {
        return enumfacing;
    }
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
public static EnumFacing getFacingFromVertexData(int[] faceData)
{
    Vector3f vector3f = new Vector3f(Float.intBitsToFloat(faceData[0]), Float.intBitsToFloat(faceData[1]), Float.intBitsToFloat(faceData[2]));
    Vector3f vector3f1 = new Vector3f(Float.intBitsToFloat(faceData[7]), Float.intBitsToFloat(faceData[8]), Float.intBitsToFloat(faceData[9]));
    Vector3f vector3f2 = new Vector3f(Float.intBitsToFloat(faceData[14]), Float.intBitsToFloat(faceData[15]), Float.intBitsToFloat(faceData[16]));
    Vector3f vector3f3 = new Vector3f();
    Vector3f vector3f4 = new Vector3f();
    Vector3f vector3f5 = new Vector3f();
    Vector3f.sub(vector3f, vector3f1, vector3f3);
    Vector3f.sub(vector3f2, vector3f1, vector3f4);
    Vector3f.cross(vector3f4, vector3f3, vector3f5);
    float f = (float)Math.sqrt(vector3f5.x * vector3f5.x + vector3f5.y * vector3f5.y + vector3f5.z * vector3f5.z);
    vector3f5.x /= f;
    vector3f5.y /= f;
    vector3f5.z /= f;
    EnumFacing enumfacing = null;
    float f1 = 0.0F;

    for (EnumFacing enumfacing1 : EnumFacing.values())
    {
        Vec3i vec3i = enumfacing1.getDirectionVec();
        Vector3f vector3f6 = new Vector3f(vec3i.getX(), vec3i.getY(), vec3i.getZ());
        float f2 = Vector3f.dot(vector3f5, vector3f6);

        if (f2 >= 0.0F && f2 > f1)
        {
            f1 = f2;
            enumfacing = enumfacing1;
        }
    }

    if (enumfacing == null)
    {
        return EnumFacing.UP;
    }
    else
    {
        return enumfacing;
    }
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
/**
 * Create a matrix that rotates around the specified axis by the specified angle.
 *
 * @param axis    The axis
 * @param radians The angle in radians
 * @return The rotation matrix
 */
public static Matrix3d getRotationMatrix(EnumFacing.Axis axis, double radians) {
    final Vec3i axisDirectionVector = AXIS_DIRECTION_VECTORS.get(axis);
    final AxisAngle4d axisAngle = new AxisAngle4d(axisDirectionVector.getX(), axisDirectionVector.getY(), axisDirectionVector.getZ(), radians);

    final Matrix3d rotationMatrix = new Matrix3d();
    rotationMatrix.set(axisAngle);

    return rotationMatrix;
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
private void shootPlayer(World world, BlockPos pos, Entity ent) {
	if (!(ent instanceof EntityPlayer)) return;
	
	IBlockState state = world.getBlockState(pos);
	EnumFacing facing = state.getValue(PROPERTY_FACING);
	Vec3i vec = facing.getDirectionVec();
	//double scale = 1.2d;
	Vec3d motion = new Vec3d(vec.getX()*scale, vec.getY()*scale, vec.getZ()*scale);
	
	ent.motionX = adjustScalar(ent.motionX, motion.x);
	ent.motionY = adjustScalar(ent.motionY, motion.y);
	ent.motionZ = adjustScalar(ent.motionZ, motion.z);
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
public boolean isConnected(World world, BlockPos from, BlockPos to){
    Vec3i diff = from.subtract(to);
    if(diff.getX() * diff.getZ() != 0)
        return false;

    return diff.getY() == 0 || !isBlockedDiagonal(world, from, to);
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
@Override
public BlockPos getNeighborACoordinate(int index) {
    if (index > Facing.values().length) index = 0;
    Vec3i coord = Facing.values()[index].getDirectionVec();
    return new BlockPos(
            pos.getX() + coord.getX(),
            pos.getY() + coord.getY(),
            pos.getZ() + coord.getZ()
    );
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
/** 
 * Transform input vector so that x & y correspond with u / v on the given face, with u,v origin at upper left
 * and z is depth, where positive values represent distance into the face (away from viewer). <br><br>
 * 
 * Coordinates are start masked to the scale of the texture being used and when we reverse an orthogonalAxis, 
 * we use the texture's sliceMask as the basis so that we remain within the frame of the
 * texture scale we are using.  <br><br>
 * 
 * Note that the x, y components are for determining min/max UV values. 
 * They should NOT be used to set vertex UV coordinates directly.
 * All bigtex models should have lockUV = true, which means that 
 * uv coordinates will be derived at time of quad bake by projecting each
 * vertex onto the plane of the quad's nominal face. 
 * Setting UV coordinates on a quad with lockUV=true has no effect.
 */
protected static Vec3i getSurfaceVector(Vec3i vec, EnumFacing face, TextureScale scale)
{
    int sliceCountMask = scale.sliceCountMask;
    int x = vec.getX() & sliceCountMask;
    int y = vec.getY() & sliceCountMask;
    int z = vec.getZ() & sliceCountMask;
    
    switch(face)
    {
    case EAST:
        return new Vec3i(sliceCountMask - z, sliceCountMask - y, -vec.getX());
    
    case WEST:
        return new Vec3i(z, sliceCountMask - y, vec.getX());
    
    case NORTH:
        return new Vec3i(sliceCountMask - x, sliceCountMask - y, vec.getZ());
    
    case SOUTH:
        return new Vec3i(x, sliceCountMask - y, -vec.getZ());
    
    case DOWN:
        return new Vec3i(x, sliceCountMask - z, vec.getY());

    case UP:
    default:
        return new Vec3i(x, z, -vec.getY());
    }
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
/** returns a copy of this quad with the given transformation applied */
public RawQuad transform(Matrix4d matrix)
{
    RawQuad result = this.clone();
    
    // transform vertices
    for(int i = 0; i < result.vertexCount; i++)
    {
        Vertex vertex = result.getVertex(i);
        Vector4d temp = new Vector4d(vertex.x, vertex.y, vertex.z, 1.0);
        matrix.transform(temp);
        if(Math.abs(temp.w - 1.0) > 1e-5) temp.scale(1.0 / temp.w);
        result.setVertex(i, vertex.withXYZ(temp.x, temp.y, temp.z));
    }
    
    // transform nominal face
    // our matrix transform has block center as its origin,
    // so need to translate face vectors to/from block center 
    // origin before/applying matrix.
    if(this.face != null)
    {
        Vec3i curNorm = this.face.getDirectionVec();
        Vector4d newFaceVec = new Vector4d(curNorm.getX() + 0.5, curNorm.getY() + 0.5, curNorm.getZ() + 0.5, 1.0);
        matrix.transform(newFaceVec);
        newFaceVec.x -= 0.5;
        newFaceVec.y -= 0.5;
        newFaceVec.z -= 0.5;
        result.setFace(QuadHelper.computeFaceForNormal(newFaceVec));
    }
    
    return result;
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
private boolean canPlaceOn(World worldIn, BlockPos pos) {

        IBlockState state = worldIn.getBlockState(pos);
        boolean canPlaceAt = (state.getBlock().canSpawnInBlock()
                || state.getBlock().canPlaceTorchOnTop(state, worldIn, pos))
                && state.getBlock().isFullBlock(state);

        BlockPos adjustedPos = new BlockPos(pos.getX(), pos.getY() + 1, pos.getZ());

        // Can't place if there is already an offering box who has claimed this
        if (canPlaceAt) {
            // Check for adjacent totem
            for (EnumFacing direction : EnumFacing.HORIZONTALS) {
                Vec3i dirVec = direction.getDirectionVec();
                BlockPos posToCheck = new BlockPos(adjustedPos.getX() + dirVec.getX(), adjustedPos.getY(), adjustedPos.getZ() + dirVec.getZ());
                TileEntity te = worldIn.getTileEntity(posToCheck);

                if (te != null
                        && te instanceof TotemTileEntity
                        && ((TotemTileEntity) te).getMaster() != null) {

                    TileEntity master = (TileEntity) ((TotemTileEntity) te).getMaster();
                    //FMLLog.log(Level.ERROR, "masterPos: " + master.getPos() + " adjustedPos: " + adjustedPos);
                    if (!master.getPos().equals(adjustedPos)) {
                        canPlaceAt = false;
                        break;
                    }
                }
            }
        }
        return canPlaceAt;
    }
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
@Override
public void onBaubleActivated(ItemStack stack, EntityPlayer player) {
    if (!player.world.isRemote) {
        if (!hasValidNbt(stack)) {
            return;
        }

        NBTTagCompound tagCompound = stack.getTagCompound();
        NBTTagCompound wolfTotemCompound = tagCompound.getCompoundTag(WOLF_TOTEM_COMPOUND);

        EntitySpiritWolf spiritWolf = getWolf(stack, player.world);
        if (spiritWolf == null
                && tagCompound.getInteger(CHARGE_LEVEL) > 0) {
            //FMLLog.log(Level.INFO, "spiritWolf is null and charge is greater than zero");
            Vec3i facingVec = player.getHorizontalFacing().getDirectionVec();
            double posX = player.posX + (facingVec.getX() * SPAWN_DISTANCE);
            double posY = player.posY;
            double posZ = player.posZ + (facingVec.getZ() * SPAWN_DISTANCE);

            // Check if spawn location is occupied by a solid block
            BlockPos blockPos = new BlockPos((int) posX, (int) posY, (int) posZ);
            if (!BlockUtils.isAreaSolid(player, blockPos)) {
                spiritWolf = spawnSpiritWolf(player.world, posX, posY, posZ);
                spiritWolf.tame(player);

                wolfTotemCompound.setString(WOLF_ID, spiritWolf.getPersistentID().toString());
            }
        } else if (spiritWolf != null) {
            //FMLLog.log(Level.INFO, "spiritWolf ain't dead. Killing and saving now.");
            spiritWolf.setDead();
            wolfTotemCompound.setString(WOLF_ID, "");
        }
        tagCompound.setTag(WOLF_TOTEM_COMPOUND, wolfTotemCompound);
    }
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
private void placeRuneAtEntity(IRune rune, ItemStack[][] pattern,World world, BlockPos lookPos, EnumFacing playerFacing,EntityPlayer player) {
	Vec3i pos = rune.getEntityPosition();
	int dX = pos.getX(),dY = pos.getY();
	EnumFacing left = playerFacing.rotateYCCW();
	BlockPos newTL = lookPos.offset(left, dX).offset(playerFacing, dY);
	PlacePatternTopLeft(pattern, world, newTL, playerFacing, player);
}
 

import net.minecraft.util.math.Vec3i; //導入方法依賴的package包/類
/**
 * Makes a flat plane along two directions
 */
public static void makePlane(int startX, int startY, int startZ, int width, int height, EnumFacing right, EnumFacing up, IShapeable shapeable) {
	if (width < 0 || height < 0) return;
	int lineOffsetX, lineOffsetY, lineOffsetZ;
	// We offset each line by up, and then apply it right

	final Vec3i v = up.getDirectionVec();
	for (int h = 0; h <= height; h++) {
		lineOffsetX = startX + (h * v.getX());
		lineOffsetY = startY + (h * v.getY());
		lineOffsetZ = startZ + (h * v.getZ());
		makeLine(lineOffsetX, lineOffsetY, lineOffsetZ, right, width, shapeable);
	}
}