Java Point3d.getZ方法代碼示例

import javax.vecmath.Point3d; //導入方法依賴的package包/類
@Override
public void playSound(double x, double y, double z, SoundEvent sound, SoundCategory category, float volume, float pitch, boolean distanceDelay) {
    Point3d transformed = this.getTransformedPosition(new Point3d(x, y, z));
    x = transformed.getX();
    y = transformed.getY();
    z = transformed.getZ();
    double distance = this.mc.getRenderViewEntity().getDistanceSq(x, y, z);
    PositionedSoundRecord positionedSound = new PositionedSoundRecord(sound, category, volume, pitch, (float) x, (float) y, (float) z);
    if (distanceDelay && distance > 100.0D) {
        double delay = Math.sqrt(distance) / 40.0D;
        this.mc.getSoundHandler().playDelayedSound(positionedSound, (int) (delay * 20.0D));
    } else {
        this.mc.getSoundHandler().playSound(positionedSound);
    }
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public void addPlayer(EntityPlayerMP player) {
    BlockSystemPlayerHandler handler = BlockSystems.PROXY.getBlockSystemHandler(player.world).get(this.blockSystem, player);
    Point3d playerPosition = this.getUntransformedPosition(player);
    int playerChunkX = (int) playerPosition.getX() >> 4;
    int playerChunkZ = (int) playerPosition.getZ() >> 4;
    handler.setManagedPosX(playerPosition.getX());
    handler.setManagedPosZ(playerPosition.getZ());
    for (int chunkX = playerChunkX - this.playerViewRadius; chunkX <= playerChunkX + this.playerViewRadius; ++chunkX) {
        for (int chunkZ = playerChunkZ - this.playerViewRadius; chunkZ <= playerChunkZ + this.playerViewRadius; ++chunkZ) {
            this.getOrCreateTracker(chunkX, chunkZ).addPlayer(player);
        }
    }
    this.players.add(player);
    this.markSortPending();
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public void updateMountedMovingPlayer(EntityPlayerMP player) {
    BlockSystemPlayerHandler handler = BlockSystems.PROXY.getBlockSystemHandler(player.world).get(this.blockSystem, player);
    Point3d playerPosition = this.getUntransformedPosition(player);
    int playerChunkX = (int) playerPosition.getX() >> 4;
    int playerChunkZ = (int) playerPosition.getZ() >> 4;
    double managedPosX = handler.getManagedPosX();
    double managedPosZ = handler.getManagedPosZ();
    double managedDeltaX = managedPosX - playerPosition.getX();
    double managedDeltaZ = managedPosZ - playerPosition.getZ();
    double managedDelta = managedDeltaX * managedDeltaX + managedDeltaZ * managedDeltaZ;
    if (managedDelta >= 64.0D) {
        int managedChunkX = (int) managedPosX >> 4;
        int managedChunkZ = (int) managedPosZ >> 4;
        int viewRadius = this.playerViewRadius;
        int deltaChunkX = playerChunkX - managedChunkX;
        int deltaChunkZ = playerChunkZ - managedChunkZ;
        if (deltaChunkX != 0 || deltaChunkZ != 0) {
            for (int chunkX = playerChunkX - viewRadius; chunkX <= playerChunkX + viewRadius; ++chunkX) {
                for (int chunkZ = playerChunkZ - viewRadius; chunkZ <= playerChunkZ + viewRadius; ++chunkZ) {
                    if (!this.interects(chunkX, chunkZ, managedChunkX, managedChunkZ, viewRadius)) {
                        this.getOrCreateTracker(chunkX, chunkZ).addPlayer(player);
                    }
                    if (!this.interects(chunkX - deltaChunkX, chunkZ - deltaChunkZ, playerChunkX, playerChunkZ, viewRadius)) {
                        BlockSystemPlayerTracker tracker = this.getTracker(chunkX - deltaChunkX, chunkZ - deltaChunkZ);
                        if (tracker != null) {
                            tracker.removePlayer(player);
                        }
                    }
                }
            }
            handler.setManagedPosX(playerPosition.getX());
            handler.setManagedPosZ(playerPosition.getZ());
            this.markSortPending();
        }
    }
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public void setPlayerViewRadius(int radius) {
    radius = MathHelper.clamp(radius, 3, 32);
    if (radius != this.playerViewRadius) {
        int deltaRadius = radius - this.playerViewRadius;
        for (EntityPlayerMP player : Lists.newArrayList(this.players)) {
            Point3d playerPosition = this.getUntransformedPosition(player);
            int playerChunkX = (int) playerPosition.getX() >> 4;
            int playerChunkZ = (int) playerPosition.getZ() >> 4;
            if (deltaRadius > 0) {
                for (int chunkX = playerChunkX - radius; chunkX <= playerChunkX + radius; ++chunkX) {
                    for (int chunkZ = playerChunkZ - radius; chunkZ <= playerChunkZ + radius; ++chunkZ) {
                        BlockSystemPlayerTracker tracker = this.getOrCreateTracker(chunkX, chunkZ);
                        if (!tracker.containsPlayer(player)) {
                            tracker.addPlayer(player);
                        }
                    }
                }
            } else {
                for (int chunkX = playerChunkX - this.playerViewRadius; chunkX <= playerChunkX + this.playerViewRadius; ++chunkX) {
                    for (int chunkZ = playerChunkZ - this.playerViewRadius; chunkZ <= playerChunkZ + this.playerViewRadius; ++chunkZ) {
                        if (!this.interects(chunkX, chunkZ, playerChunkX, playerChunkZ, radius)) {
                            this.getOrCreateTracker(chunkX, chunkZ).removePlayer(player);
                        }
                    }
                }
            }
        }
        this.playerViewRadius = radius;
        this.markSortPending();
    }
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
@Override
public EntityPlayer getClosestPlayer(double posX, double posY, double posZ, double distance, boolean spectator) {
    Point3d transformed = this.getTransformedPosition(new Point3d(posX, posY, posZ));
    posX = transformed.getX();
    posY = transformed.getY();
    posZ = transformed.getZ();
    return this.mainWorld.getClosestPlayer(posX, posY, posZ, distance, spectator);
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
@Override
public EntityPlayer getNearestAttackablePlayer(double posX, double posY, double posZ, double maxXZDistance, double maxYDistance, Function<EntityPlayer, Double> serializer, Predicate<EntityPlayer> selector) {
    Point3d transformed = this.getTransformedPosition(new Point3d(posX, posY, posZ));
    posX = transformed.getX();
    posY = transformed.getY();
    posZ = transformed.getZ();
    return this.mainWorld.getNearestAttackablePlayer(posX, posY, posZ, maxXZDistance, maxYDistance, serializer, selector);
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
@Override
public void spawnParticle(EnumParticleTypes particleType, double posX, double posY, double posZ, double xSpeed, double ySpeed, double zSpeed, int... parameters) {
    Point3d transformed = this.getTransformedPosition(new Point3d(posX, posY, posZ));
    posX = transformed.getX();
    posY = transformed.getY();
    posZ = transformed.getZ();
    if (particleType != EnumParticleTypes.REDSTONE) {
        Vec3d transformedVelocity = this.getTransformedVector(new Vec3d(xSpeed, ySpeed, zSpeed));
        xSpeed = transformedVelocity.xCoord;
        ySpeed = transformedVelocity.yCoord;
        zSpeed = transformedVelocity.zCoord;
    }
    super.spawnParticle(particleType, posX, posY, posZ, xSpeed, ySpeed, zSpeed, parameters);
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
@Override
public void playSound(EntityPlayer player, double x, double y, double z, SoundEvent sound, SoundCategory category, float volume, float pitch) {
    Point3d transformed = this.getTransformedPosition(new Point3d(x, y, z));
    x = transformed.getX();
    y = transformed.getY();
    z = transformed.getZ();
    super.playSound(player, x, y, z, sound, category, volume, pitch);
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public static void transformEffect(Particle particle) {
    BlockSystem transforming = BlockSystem.transforming;
    if (transforming != null) {
        Point3d transformed = transforming.getTransformedPosition(new Point3d(particle.posX, particle.posY, particle.posZ));
        particle.setPosition(transformed.getX(), transformed.getY(), transformed.getZ());
        particle.prevPosX = transformed.getX();
        particle.prevPosY = transformed.getY();
        particle.prevPosZ = transformed.getZ();
        Vec3d transformedVelocity = transforming.getTransformedVector(new Vec3d(particle.motionX, particle.motionY, particle.motionZ));
        particle.motionX = transformedVelocity.xCoord;
        particle.motionY = transformedVelocity.yCoord;
        particle.motionZ = transformedVelocity.zCoord;
    }
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
/**
 * Renvoie le triangle qui se trouve dans la maille indexX, indexY et dans le
 * bas de la maille si inferior est true et dans le haut de celle-ci sinon
 * Renvoie null si les indices ne correspondent pas à un triangle existant
 * 
 * @param indexX l'indice de la maille en X
 * @param indexY l'indice de la maille en Y
 * @param inferior la position du triangle par rapport à la maille
 * @return une liste de points correspondants au sommet du triangle concerné
 */
public DirectPositionList getTriangle(int indexX, int indexY, boolean inferior) {

  // Si les coordonnées ne sont pas dans le MNT, on renvoie null
  if (indexX >= (this.nX - 1) || indexX < 0 || indexY >= (this.nY - 1)
      || indexY < 0) {

    return null;

  }
  // On récupère les 4 coordonnées potentielle
  int lignInit2 = 2 * (indexX) + 2 * (this.nY - 1 - (indexY + 1)) * this.nX;

  Point3d pointemp1 = new Point3d();
  this.strip.getCoordinate(lignInit2, pointemp1);

  Point3d pointemp2 = new Point3d();
  this.strip.getCoordinate(lignInit2 + 1, pointemp2);

  Point3d pointemp3 = new Point3d();
  this.strip.getCoordinate(lignInit2 + 2, pointemp3);

  Point3d pointemp4 = new Point3d();
  this.strip.getCoordinate(lignInit2 + 3, pointemp4);

  DirectPosition pt12D = new DirectPosition(pointemp1.x + this.xIni,
      pointemp1.y + this.yIni, pointemp1.getZ());
  DirectPosition pt22D = new DirectPosition(pointemp2.x + this.xIni,
      pointemp2.y + this.yIni, pointemp2.getZ());
  DirectPosition pt32D = new DirectPosition(pointemp3.x + this.xIni,
      pointemp3.y + this.yIni, pointemp3.getZ());
  DirectPosition pt42D = new DirectPosition(pointemp4.x + this.xIni,
      pointemp4.y + this.yIni, pointemp4.getZ());

  DirectPositionList dpl = new DirectPositionList();

  if (inferior) {

    dpl.add(pt12D);
    dpl.add(pt22D);
    dpl.add(pt32D);

  } else {

    dpl.add(pt42D);
    dpl.add(pt22D);
    dpl.add(pt32D);
  }

  return dpl;
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public Vec3d getTransformedPosition(Vec3d position) {
    Point3d point = new Point3d(position.xCoord - 0.5, position.yCoord, position.zCoord - 0.5);
    this.transformMatrix.transform(point);
    return new Vec3d(point.getX(), point.getY(), point.getZ());
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public Vec3d getUntransformedPosition(Vec3d position) {
    Point3d point = new Point3d(position.xCoord, position.yCoord, position.zCoord);
    this.untransformMatrix.transform(point);
    return new Vec3d(point.getX() + 0.5, point.getY(), point.getZ() + 0.5);
}
 

import javax.vecmath.Point3d; //導入方法依賴的package包/類
public Vec3d transformPoint(Vec3d vec) {
    Point3d point = new Point3d(vec.xCoord, vec.yCoord, vec.zCoord);
    this.transform(point);
    return new Vec3d(point.getX(), point.getY(), point.getZ());
}