com.jogamp.opengl.math.geom

## Class AABBox

- java.lang.Object
- - com.jogamp.opengl.math.geom.AABBox

-     public class AABBox
      extends Object

  Axis Aligned Bounding Box. Defined by two 3D coordinates (low and high) The low being the the lower left corner of the box, and the high being the upper right corner of the box.

  A few references for collision detection, intersections:

       http://www.realtimerendering.com/intersections.html
       http://www.codercorner.com/RayAABB.cpp
       http://www.siggraph.org/education/materials/HyperGraph/raytrace/rtinter0.htm
       http://realtimecollisiondetection.net/files/levine_swept_sat.txt

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AABBox()` Create an Axis Aligned bounding box (AABBox) where the low and and high MAX float Values.
    `AABBox(AABBox src)` Create an AABBox copying all values from the given one
    `AABBox(float[] low, float[] high)` Create a AABBox defining the low and high
    `AABBox(float lx, float ly, float lz, float hx, float hy, float hz)` Create an AABBox specifying the coordinates of the low and high

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `contains(float x, float y)` Check if the x & y coordinates are bounded/contained by this AABBox
    `boolean` | `contains(float x, float y, float z)` Check if the xyz coordinates are bounded/contained by this AABBox.
    `AABBox` | `copy(AABBox src)` Copy given AABBox 'src' values to this AABBox.
    `boolean` | `equals(Object obj)`
    `float[]` | `getCenter()` Get the Center of this AABBox
    `float` | `getDepth()`
    `float` | `getHeight()`
    `float[]` | `getHigh()` Get the max xyz-coordinates
    `float[]` | `getLow()` Get the min xyz-coordinates
    `float` | `getMaxX()`
    `float` | `getMaxY()`
    `float` | `getMaxZ()`
    `float` | `getMinX()`
    `float` | `getMinY()`
    `float` | `getMinZ()`
    `float[]` | `getRayIntersection(float[] result, Ray ray, float epsilon, boolean assumeIntersection, float[] tmp1V3, float[] tmp2V3, float[] tmp3V3)` Return intersection of a `Ray` with this bounding box, or null if none exist.
    `float` | `getSize()` Get the size of this AABBox where the size is represented by the length of the vector between low and high.
    `float` | `getWidth()`
    `int` | `hashCode()`
    `boolean` | `intersects2DRegion(float x, float y, float w, float h)` Check if there is a common region between this AABBox and the passed 2D region irrespective of z range
    `boolean` | `intersectsRay(Ray ray)` Check if `Ray` intersects this bounding box.
    `AABBox` | `mapToWindow(AABBox result, float[] mat4PMv, int[] view, boolean useCenterZ, float[] vec3Tmp0, float[] vec4Tmp1, float[] vec4Tmp2)` Assume this bounding box as being in object space and compute the window bounding box.
    `AABBox` | `reset()` resets this box to the inverse low/high, allowing the next `resize(float, float, float)` command to hit.
    `AABBox` | `resize(AABBox newBox)` Resize the AABBox to encapsulate another AABox
    `AABBox` | `resize(AABBox newBox, jogamp.graph.geom.plane.AffineTransform t, float[] tmpV3)` Resize the AABBox to encapsulate another AABox, which will be transformed on the fly first.
    `AABBox` | `resize(float[] xyz)` Resize the AABBox to encapsulate the passed xyz-coordinates.
    `AABBox` | `resize(float[] xyz, int offset)` Resize the AABBox to encapsulate the passed xyz-coordinates.
    `AABBox` | `resize(float x, float y, float z)` Resize the AABBox to encapsulate the passed xyz-coordinates.
    `AABBox` | `rotate(Quaternion quat)` Rotate this AABBox by a float[3] vector
    `AABBox` | `scale(float size, float[] tmpV3)` Scale this AABBox by a constant
    `AABBox` | `setSize(float[] low, float[] high)` Set size of the AABBox specifying the coordinates of the low and high.
    `AABBox` | `setSize(float lx, float ly, float lz, float hx, float hy, float hz)` Set size of the AABBox specifying the coordinates of the low and high.
    `String` | `toString()`
    `AABBox` | `translate(float[] t)` Translate this AABBox by a float[3] vector

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AABBox

          public AABBox()

      Create an Axis Aligned bounding box (AABBox) where the low and and high MAX float Values.

    - #### AABBox

          public AABBox(AABBox src)

      Create an AABBox copying all values from the given one
      Parameters:
        `src` - the box value to be used for the new instance

    - #### AABBox

          public AABBox(float lx,
                float ly,
                float lz,
                float hx,
                float hy,
                float hz)

      Create an AABBox specifying the coordinates of the low and high
      Parameters:
        `lx` - min x-coordinate
        `ly` - min y-coordnate
        `lz` - min z-coordinate
        `hx` - max x-coordinate
        `hy` - max y-coordinate
        `hz` - max z-coordinate

    - #### AABBox

          public AABBox(float[] low,
                float[] high)

      Create a AABBox defining the low and high
      Parameters:
        `low` - min xyz-coordinates
        `high` - max xyz-coordinates

  - ### Method Detail

    - #### reset

          public final AABBox reset()

      resets this box to the inverse low/high, allowing the next `resize(float, float, float)` command to hit.
      Returns:
        this AABBox for chaining

    - #### getHigh

          public final float[] getHigh()

      Get the max xyz-coordinates
      Returns:
        a float array containing the max xyz coordinates

    - #### getLow

          public final float[] getLow()

      Get the min xyz-coordinates
      Returns:
        a float array containing the min xyz coordinates

    - #### copy

          public final AABBox copy(AABBox src)

      Copy given AABBox 'src' values to this AABBox.
      Parameters:
        `src` - source AABBox
      Returns:
        this AABBox for chaining

    - #### setSize

          public final AABBox setSize(float[] low,
                       float[] high)

      Set size of the AABBox specifying the coordinates of the low and high.
      Parameters:
        `low` - min xyz-coordinates
        `high` - max xyz-coordinates
      Returns:
        this AABBox for chaining

    - #### setSize

          public final AABBox setSize(float lx,
                       float ly,
                       float lz,
                       float hx,
                       float hy,
                       float hz)

      Set size of the AABBox specifying the coordinates of the low and high.
      Parameters:
        `lx` - min x-coordinate
        `ly` - min y-coordnate
        `lz` - min z-coordinate
        `hx` - max x-coordinate
        `hy` - max y-coordinate
        `hz` - max z-coordinate
      Returns:
        this AABBox for chaining

    - #### resize

          public final AABBox resize(AABBox newBox)

      Resize the AABBox to encapsulate another AABox
      Parameters:
        `newBox` - AABBox to be encapsulated in
      Returns:
        this AABBox for chaining

    - #### resize

          public final AABBox resize(AABBox newBox,
                      jogamp.graph.geom.plane.AffineTransform t,
                      float[] tmpV3)

      Resize the AABBox to encapsulate another AABox, which will be transformed on the fly first.
      Parameters:
        `newBox` - AABBox to be encapsulated in
        `t` - the `AffineTransform` applied on newBox on the fly
        `tmpV3` - temp float[3] storage
      Returns:
        this AABBox for chaining

    - #### resize

          public final AABBox resize(float x,
                      float y,
                      float z)

      Resize the AABBox to encapsulate the passed xyz-coordinates.
      Parameters:
        `x` - x-axis coordinate value
        `y` - y-axis coordinate value
        `z` - z-axis coordinate value
      Returns:
        this AABBox for chaining

    - #### resize

          public final AABBox resize(float[] xyz,
                      int offset)

      Resize the AABBox to encapsulate the passed xyz-coordinates.
      Parameters:
        `xyz` - xyz-axis coordinate values
        `offset` - of the array
      Returns:
        this AABBox for chaining

    - #### resize

          public final AABBox resize(float[] xyz)

      Resize the AABBox to encapsulate the passed xyz-coordinates.
      Parameters:
        `xyz` - xyz-axis coordinate values
      Returns:
        this AABBox for chaining

    - #### contains

          public final boolean contains(float x,
                         float y)

      Check if the x & y coordinates are bounded/contained by this AABBox
      Parameters:
        `x` - x-axis coordinate value
        `y` - y-axis coordinate value
      Returns:
        true if x belong to (low.x, high.x) and y belong to (low.y, high.y)

    - #### contains

          public final boolean contains(float x,
                         float y,
                         float z)

      Check if the xyz coordinates are bounded/contained by this AABBox.
      Parameters:
        `x` - x-axis coordinate value
        `y` - y-axis coordinate value
        `z` - z-axis coordinate value
      Returns:
        true if x belong to (low.x, high.x) and y belong to (low.y, high.y) and z belong to (low.z, high.z)

    - #### intersects2DRegion

          public final boolean intersects2DRegion(float x,
                                   float y,
                                   float w,
                                   float h)

      Check if there is a common region between this AABBox and the passed 2D region irrespective of z range
      Parameters:
        `x` - lower left x-coord
        `y` - lower left y-coord
        `w` - width
        `h` - hight
      Returns:
        true if this AABBox might have a common region with this 2D region

    - #### intersectsRay

          public final boolean intersectsRay(Ray ray)

      Check if `Ray` intersects this bounding box.

      Versions uses the SAT[1], testing 6 axes. Original code for OBBs from MAGIC. Rewritten for AABBs and reorganized for early exits[2].

           [1] SAT = Separating Axis Theorem
           [2] http://www.codercorner.com/RayAABB.cpp

      Parameters:
        `ray` -
      Returns:

    - #### getRayIntersection

          public final float[] getRayIntersection(float[] result,
                                   Ray ray,
                                   float epsilon,
                                   boolean assumeIntersection,
                                   float[] tmp1V3,
                                   float[] tmp2V3,
                                   float[] tmp3V3)

      Return intersection of a `Ray` with this bounding box, or null if none exist.

      - Original code by Andrew Woo, from "Graphics Gems", Academic Press, 1990 [2]
      - Optimized code by Pierre Terdiman, 2000 (~20-30% faster on my Celeron 500)
      - Epsilon value added by Klaus Hartmann.
      Method is based on the requirements:
      - the integer representation of 0.0f is 0x00000000
      - the sign bit of the float is the most significant one
      Report bugs: p.terdiman@codercorner.com

           [1] http://www.codercorner.com/RayAABB.cpp
           [2] http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c

      Parameters:
        `result` - vec3
        `ray` -
        `epsilon` -
        `assumeIntersection` - if true, method assumes an intersection, i.e. by pre-checking via `intersectsRay(Ray)`. In this case method will not validate a possible non-intersection and just computes coordinates.
        `tmp1V3` - temp vec3
        `tmp2V3` - temp vec3
        `tmp3V3` - temp vec3
      Returns:
        float[3] result of intersection coordinates, or null if none exists

    - #### getSize

          public final float getSize()

      Get the size of this AABBox where the size is represented by the length of the vector between low and high.
      Returns:
        a float representing the size of the AABBox

    - #### getCenter

          public final float[] getCenter()

      Get the Center of this AABBox
      Returns:
        the xyz-coordinates of the center of the AABBox

    - #### scale

          public final AABBox scale(float size,
                     float[] tmpV3)

      Scale this AABBox by a constant
      Parameters:
        `size` - a constant float value
        `tmpV3` - caller provided temporary 3-component vector
      Returns:
        this AABBox for chaining

    - #### translate

          public final AABBox translate(float[] t)

      Translate this AABBox by a float[3] vector
      Parameters:
        `t` - the float[3] translation vector
      Returns:
        this AABBox for chaining

    - #### rotate

          public final AABBox rotate(Quaternion quat)

      Rotate this AABBox by a float[3] vector
      Parameters:
        `quat` - the `Quaternion` used for rotation
      Returns:
        this AABBox for chaining

    - #### getMinX

          public final float getMinX()

    - #### getMinY

          public final float getMinY()

    - #### getMinZ

          public final float getMinZ()

    - #### getMaxX

          public final float getMaxX()

    - #### getMaxY

          public final float getMaxY()

    - #### getMaxZ

          public final float getMaxZ()

    - #### getWidth

          public final float getWidth()

    - #### getHeight

          public final float getHeight()

    - #### getDepth

          public final float getDepth()

    - #### equals

          public final boolean equals(Object obj)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public final int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### mapToWindow

          public AABBox mapToWindow(AABBox result,
                           float[] mat4PMv,
                           int[] view,
                           boolean useCenterZ,
                           float[] vec3Tmp0,
                           float[] vec4Tmp1,
                           float[] vec4Tmp2)

      Assume this bounding box as being in object space and compute the window bounding box.

      If `useCenterZ` is `true`, only 4 `mapObjToWinCoords` operations are made on points [1..4] using `getCenter()`'s z-value. Otherwise 8 `mapObjToWinCoords` operation on all 8 points are performed.

            [2] ------ [4]
             |          |
             |          |
            [1] ------ [3]

      Parameters:
        `mat4PMv` - P x Mv matrix
        `view` -
        `useCenterZ` -
        `vec3Tmp0` - 3 component vector for temp storage
        `vec4Tmp1` - 4 component vector for temp storage
        `vec4Tmp2` - 4 component vector for temp storage
      Returns:

    - #### toString

          public final String toString()

      Overrides:
        `toString` in class `Object`

Copyright 2010 JogAmp Community.