| github_url: | hide |
|---|
A 3D axis-aligned bounding box.
.. rst-class:: classref-introduction-group
AABB consists of a position, a size, and several utility functions. It is typically used for fast overlap tests.
It uses floating-point coordinates. The 2D counterpart to AABB is :ref:`Rect2<class_Rect2>`.
Negative values for :ref:`size<class_AABB_property_size>` are not supported and will not work for most methods. Use :ref:`abs<class_AABB_method_abs>` to get an AABB with a positive size.
Note: Unlike :ref:`Rect2<class_Rect2>`, AABB does not have a variant that uses integer coordinates.
Note
There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information.
.. rst-class:: classref-introduction-group
- :doc:`Math documentation index <../tutorials/math/index>`
- :doc:`Vector math <../tutorials/math/vector_math>`
- :doc:`Advanced vector math <../tutorials/math/vectors_advanced>`
.. rst-class:: classref-reftable-group
| :ref:`Vector3<class_Vector3>` | :ref:`end<class_AABB_property_end>` | Vector3(0, 0, 0) |
| :ref:`Vector3<class_Vector3>` | :ref:`position<class_AABB_property_position>` | Vector3(0, 0, 0) |
| :ref:`Vector3<class_Vector3>` | :ref:`size<class_AABB_property_size>` | Vector3(0, 0, 0) |
.. rst-class:: classref-reftable-group
.. rst-class:: classref-reftable-group
.. rst-class:: classref-reftable-group
.. rst-class:: classref-section-separator
.. rst-class:: classref-descriptions-group
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` end = Vector3(0, 0, 0)
Ending corner. This is calculated as position + size. Setting this value will change the size.
.. rst-class:: classref-item-separator
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` position = Vector3(0, 0, 0)
Beginning corner. Typically has values lower than :ref:`end<class_AABB_property_end>`.
.. rst-class:: classref-item-separator
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` size = Vector3(0, 0, 0)
Size from :ref:`position<class_AABB_property_position>` to :ref:`end<class_AABB_property_end>`. Typically, all components are positive.
If the size is negative, you can use :ref:`abs<class_AABB_method_abs>` to fix it.
.. rst-class:: classref-section-separator
.. rst-class:: classref-descriptions-group
.. rst-class:: classref-constructor
:ref:`AABB<class_AABB>` AABB ( )
Constructs a default-initialized AABB with default (zero) values of :ref:`position<class_AABB_property_position>` and :ref:`size<class_AABB_property_size>`.
.. rst-class:: classref-item-separator
.. rst-class:: classref-constructor
:ref:`AABB<class_AABB>` AABB ( :ref:`AABB<class_AABB>` from )
Constructs an AABB as a copy of the given AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-constructor
:ref:`AABB<class_AABB>` AABB ( :ref:`Vector3<class_Vector3>` position, :ref:`Vector3<class_Vector3>` size )
Constructs an AABB from a position and size.
.. rst-class:: classref-section-separator
.. rst-class:: classref-descriptions-group
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` abs ( ) |const|
Returns an AABB with equivalent position and size, modified so that the most-negative corner is the origin and the size is positive.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` encloses ( :ref:`AABB<class_AABB>` with ) |const|
Returns true if this AABB completely encloses another one.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` expand ( :ref:`Vector3<class_Vector3>` to_point ) |const|
Returns a copy of this AABB expanded to include a given point.
Example:
.. tabs::
.. code-tab:: gdscript
# position (-3, 2, 0), size (1, 1, 1)
var box = AABB(Vector3(-3, 2, 0), Vector3(1, 1, 1))
# position (-3, -1, 0), size (3, 4, 2), so we fit both the original AABB and Vector3(0, -1, 2)
var box2 = box.expand(Vector3(0, -1, 2))
.. code-tab:: csharp
// position (-3, 2, 0), size (1, 1, 1)
var box = new Aabb(new Vector3(-3, 2, 0), new Vector3(1, 1, 1));
// position (-3, -1, 0), size (3, 4, 2), so we fit both the original AABB and Vector3(0, -1, 2)
var box2 = box.Expand(new Vector3(0, -1, 2));
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` get_center ( ) |const|
Returns the center of the AABB, which is equal to :ref:`position<class_AABB_property_position>` + (:ref:`size<class_AABB_property_size>` / 2).
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` get_endpoint ( :ref:`int<class_int>` idx ) |const|
Gets the position of the 8 endpoints of the AABB in space.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` get_longest_axis ( ) |const|
Returns the normalized longest axis of the AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`int<class_int>` get_longest_axis_index ( ) |const|
Returns the index of the longest axis of the AABB (according to :ref:`Vector3<class_Vector3>`'s AXIS_* constants).
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`float<class_float>` get_longest_axis_size ( ) |const|
Returns the scalar length of the longest axis of the AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` get_shortest_axis ( ) |const|
Returns the normalized shortest axis of the AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`int<class_int>` get_shortest_axis_index ( ) |const|
Returns the index of the shortest axis of the AABB (according to :ref:`Vector3<class_Vector3>`::AXIS* enum).
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`float<class_float>` get_shortest_axis_size ( ) |const|
Returns the scalar length of the shortest axis of the AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` get_support ( :ref:`Vector3<class_Vector3>` dir ) |const|
Returns the support point in a given direction. This is useful for collision detection algorithms.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`float<class_float>` get_volume ( ) |const|
Returns the volume of the AABB.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` grow ( :ref:`float<class_float>` by ) |const|
Returns a copy of the AABB grown a given number of units towards all the sides.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` has_point ( :ref:`Vector3<class_Vector3>` point ) |const|
Returns true if the AABB contains a point. Points on the faces of the AABB are considered included, though float-point precision errors may impact the accuracy of such checks.
Note: This method is not reliable for AABB with a negative size. Use :ref:`abs<class_AABB_method_abs>` to get a positive sized equivalent AABB to check for contained points.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` has_surface ( ) |const|
Returns true if the AABB has a surface or a length, and false if the AABB is empty (all components of :ref:`size<class_AABB_property_size>` are zero or negative).
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` has_volume ( ) |const|
Returns true if the AABB has a volume, and false if the AABB is flat, empty, or has a negative :ref:`size<class_AABB_property_size>`.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` intersection ( :ref:`AABB<class_AABB>` with ) |const|
Returns the intersection between two AABB. An empty AABB (size (0, 0, 0)) is returned on failure.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` intersects ( :ref:`AABB<class_AABB>` with ) |const|
Returns true if the AABB overlaps with another.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` intersects_plane ( :ref:`Plane<class_Plane>` plane ) |const|
Returns true if the AABB is on both sides of a plane.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` intersects_ray ( :ref:`Vector3<class_Vector3>` from, :ref:`Vector3<class_Vector3>` dir ) |const|
Returns the point of intersection of the given ray with this AABB or null if there is no intersection. Ray length is infinite.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` intersects_segment ( :ref:`Vector3<class_Vector3>` from, :ref:`Vector3<class_Vector3>` to ) |const|
Returns the point of intersection between from and to with this AABB or null if there is no intersection.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` is_equal_approx ( :ref:`AABB<class_AABB>` aabb ) |const|
Returns true if this AABB and aabb are approximately equal, by calling :ref:`@GlobalScope.is_equal_approx<class_@GlobalScope_method_is_equal_approx>` on each component.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`bool<class_bool>` is_finite ( ) |const|
Returns true if this AABB is finite, by calling :ref:`@GlobalScope.is_finite<class_@GlobalScope_method_is_finite>` on each component.
.. rst-class:: classref-item-separator
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` merge ( :ref:`AABB<class_AABB>` with ) |const|
Returns a larger AABB that contains both this AABB and with.
.. rst-class:: classref-section-separator
.. rst-class:: classref-descriptions-group
.. rst-class:: classref-operator
:ref:`bool<class_bool>` operator != ( :ref:`AABB<class_AABB>` right )
Returns true if the AABBs are not equal.
Note: Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_AABB_method_is_equal_approx>` instead, which is more reliable.
.. rst-class:: classref-item-separator
.. rst-class:: classref-operator
:ref:`AABB<class_AABB>` operator * ( :ref:`Transform3D<class_Transform3D>` right )
Inversely transforms (multiplies) the AABB by the given :ref:`Transform3D<class_Transform3D>` transformation matrix.
.. rst-class:: classref-item-separator
.. rst-class:: classref-operator
:ref:`bool<class_bool>` operator == ( :ref:`AABB<class_AABB>` right )
Returns true if the AABBs are exactly equal.
Note: Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_AABB_method_is_equal_approx>` instead, which is more reliable.