Class AABB

java.lang.Object
net.minecraft.world.phys.AABB
public class AABB extends Object

  • Field Details

    • EPSILON

      private static final double EPSILON
      See Also:

    • INFINITE

      public static final AABB INFINITE

    • minX

      public final double minX

    • minY

      public final double minY

    • minZ

      public final double minZ

    • maxX

      public final double maxX

    • maxY

      public final double maxY

    • maxZ

      public final double maxZ

  • Constructor Details

    • AABB

      public AABB(double minX, double minY, double minZ, double maxX, double maxY, double maxZ)

    • AABB

      public AABB(BlockPos pos)

    • AABB

      public AABB(Vec3 begin, Vec3 end)

  • Method Details

    • of

      public static AABB of(BoundingBox box)

    • unitCubeFromLowerCorner

      public static AABB unitCubeFromLowerCorner(Vec3 pos)

    • encapsulatingFullBlocks

      public static AABB encapsulatingFullBlocks(BlockPos pos0, BlockPos pos1)

    • setMinX

      public AABB setMinX(double minX)

    • setMinY

      public AABB setMinY(double minY)

    • setMinZ

      public AABB setMinZ(double minZ)

    • setMaxX

      public AABB setMaxX(double maxX)

    • setMaxY

      public AABB setMaxY(double maxY)

    • setMaxZ

      public AABB setMaxZ(double maxZ)

    • min

      public double min(Direction.Axis axis)

    • max

      public double max(Direction.Axis axis)

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • contract

      public AABB contract(double xa, double ya, double za)
      Creates a new AABB that has been contracted by the given amount, with positive changes decreasing max values and negative changes increasing min values.
      If the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see last sample).

      Samples:

      InputResult
      new AABB(0, 0, 0, 4, 4, 4).contract(2, 2, 2)
      box[0.0, 0.0, 0.0 -> 2.0, 2.0, 2.0]
      new AABB(0, 0, 0, 4, 4, 4).contract(-2, -2, -2)
      box[2.0, 2.0, 2.0 -> 4.0, 4.0, 4.0]
      new AABB(5, 5, 5, 7, 7, 7).contract(0, 1, -1)
      box[5.0, 5.0, 6.0 -> 7.0, 6.0, 7.0]
      new AABB(-2, -2, -2, 2, 2, 2).contract(4, -4, 0)
      box[-8.0, 2.0, -2.0 -> -2.0, 8.0, 2.0]

      See Also:

      • invalid reference 
        #expand(double, double, double)
        - like this, except for expanding.
      • invalid reference 
        #grow(double, double, double)
        and
        invalid reference 
        #grow(double)
        - expands in all directions.
      • invalid reference 
        #shrink(double)
        - contracts in all directions (like
        invalid reference 
        #grow(double)
        )
      Returns:
      A new modified bounding box.

    • expandTowards

      public AABB expandTowards(Vec3 delta)

    • expandTowards

      public AABB expandTowards(double xa, double ya, double za)
      Creates a new AABB that has been expanded by the given amount, with positive changes increasing max values and negative changes decreasing min values.

      Samples:

      InputResult
      new AABB(0, 0, 0, 1, 1, 1).expand(2, 2, 2)
      box[0, 0, 0 -> 3, 3, 3]
      		 
      new AABB(0, 0, 0, 1, 1, 1).expand(-2, -2, -2)
      box[-2, -2, -2 -> 1, 1, 1]
      		 
      new AABB(5, 5, 5, 7, 7, 7).expand(0, 1, -1)
      box[5, 5, 4, 7, 8, 7]

      See Also:

      • contract(double, double, double) - like this, except for shrinking.
      • invalid reference 
        #grow(double, double, double)
        and
        invalid reference 
        #grow(double)
        - expands in all directions.
      • invalid reference 
        #shrink(double)
        - contracts in all directions (like
        invalid reference 
        #grow(double)
        )
      Returns:
      A modified bounding box that will always be equal or greater in volume to this bounding box.

    • inflate

      public AABB inflate(double xAdd, double yAdd, double zAdd)
      Creates a new AABB that has been contracted by the given amount in both directions. Negative values will shrink the AABB instead of expanding it.
      Side lengths will be increased by 2 times the value of the parameters, since both min and max are changed.
      If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see last ample).

      Samples:

      InputResult
      new AABB(0, 0, 0, 1, 1, 1).grow(2, 2, 2)
      box[-2.0, -2.0, -2.0 -> 3.0, 3.0, 3.0]
      new AABB(0, 0, 0, 6, 6, 6).grow(-2, -2, -2)
      box[2.0, 2.0, 2.0 -> 4.0, 4.0, 4.0]
      new AABB(5, 5, 5, 7, 7, 7).grow(0, 1, -1)
      box[5.0, 4.0, 6.0 -> 7.0, 8.0, 6.0]
      new AABB(1, 1, 1, 3, 3, 3).grow(-4, -2, -3)
      box[-1.0, 1.0, 0.0 -> 5.0, 3.0, 4.0]

      See Also:

      • invalid reference 
        #expand(double, double, double)
        - expands in only one direction.
      • contract(double, double, double) - contracts in only one direction.
        • invalid reference 
        #grow(double)
        - version of this that expands in all directions from one parameter.
      • invalid reference 
        #shrink(double)
        - contracts in all directions
      Returns:
      A modified bounding box.

    • inflate

      public AABB inflate(double amountToAddInAllDirections)
      Creates a new AABB that is expanded by the given value in all directions. Equivalent to
      invalid reference 
      #grow(double, double, double)
      with the given value for all 3 params. Negative values will shrink the AABB.
      Side lengths will be increased by 2 times the value of the parameter, since both min and max are changed.
      If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see samples on
      invalid reference 
      #grow(double, double, double)
      ).
      Returns:
      A modified AABB.

    • intersect

      public AABB intersect(AABB other)

    • minmax

      public AABB minmax(AABB other)

    • move

      public AABB move(double xa, double ya, double za)
      Offsets the current bounding box by the specified amount.

    • move

      public AABB move(BlockPos pos)

    • move

      public AABB move(Vec3 pos)

    • move

      public AABB move(Vector3f pos)

    • intersects

      public boolean intersects(AABB aabb)
      Checks if the bounding box intersects with another.

    • intersects

      public boolean intersects(double minX, double minY, double minZ, double maxX, double maxY, double maxZ)

    • intersects

      public boolean intersects(Vec3 min, Vec3 max)

    • intersects

      public boolean intersects(BlockPos pos)

    • contains

      public boolean contains(Vec3 vec)
      Returns if the supplied Vec3D is completely inside the bounding box

    • contains

      public boolean contains(double x, double y, double z)

    • getSize

      public double getSize()

    • getXsize

      public double getXsize()

    • getYsize

      public double getYsize()

    • getZsize

      public double getZsize()

    • deflate

      public AABB deflate(double xSubstract, double ySubtract, double zSubtract)

    • deflate

      public AABB deflate(double amount)
      Creates a new AABB that is expanded by the given value in all directions. Equivalent to
      invalid reference 
      #grow(double)
      with value set to the negative of the value provided here. Passing a negative value to this method values will grow the AABB.
      Side lengths will be decreased by 2 times the value of the parameter, since both min and max are changed.
      If contracting and the amount to contract by is larger than the length of a side, then the side will wrap (still creating a valid AABB - see samples on
      invalid reference 
      #grow(double, double, double)
      ).
      Returns:
      A modified AABB.

    • clip

      public Optional<Vec3> clip(Vec3 from, Vec3 to)

    • clip

      public static Optional<Vec3> clip(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vec3 from, Vec3 to)

    • clip

      public static @Nullable BlockHitResult clip(Iterable<AABB> aabBs, Vec3 from, Vec3 to, BlockPos pos)

    • getDirection

      private static @Nullable Direction getDirection(AABB aabb, Vec3 from, double[] scaleReference, @Nullable Direction direction, double dx, double dy, double dz)

    • getDirection

      private static @Nullable Direction getDirection(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vec3 from, double[] scaleReference, @Nullable Direction direction, double dx, double dy, double dz)

    • clipPoint

      private static @Nullable Direction clipPoint(double[] scaleReference, @Nullable Direction direction, double da, double db, double dc, double point, double minB, double maxB, double minC, double maxC, Direction newDirection, double fromA, double fromB, double fromC)

    • collidedAlongVector

      public boolean collidedAlongVector(Vec3 vector, List<AABB> aabbs)

    • distanceToSqr

      public double distanceToSqr(Vec3 point)

    • distanceToSqr

      public double distanceToSqr(AABB boundingBox)

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • hasNaN

      public boolean hasNaN()

    • getCenter

      public Vec3 getCenter()

    • getBottomCenter

      public Vec3 getBottomCenter()

    • getMinPosition

      public Vec3 getMinPosition()

    • getMaxPosition

      public Vec3 getMaxPosition()

    • ofSize

      public static AABB ofSize(Vec3 center, double sizeX, double sizeY, double sizeZ)

    • isInfinite

      public boolean isInfinite()
      Returns true if this AABB is infinite in all directions.
      Returns:
      true if this AABB is infinite in all directions