VectorUtil (JOGL, NativeWindow and NEWT APIs)

java.lang.Object
- com.jogamp.opengl.math.VectorUtil

public final class VectorUtil
extends Object

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class VectorUtil.Winding

Nested Classes
Modifier and Type	Class and Description
`static class`	`VectorUtil.Winding`

Field Summary

Fields
Modifier and Type	Field and Description
`static float[]`	`VEC3_ONE`
`static float[]`	`VEC3_UNIT_Y`
`static float[]`	`VEC3_UNIT_Y_NEG`
`static float[]`	`VEC3_UNIT_Z`
`static float[]`	`VEC3_UNIT_Z_NEG`
`static float[]`	`VEC3_ZERO`

Constructor Summary

Constructors
Constructor and Description

VectorUtil()

Constructors
Constructor and Description
`VectorUtil()`

Method Summary

Methods
Modifier and Type	Method and Description
`static float[]`	`addVec2(float[] result, float[] v1, float[] v2)` Adds two vectors, result = v1 + v2
`static float[]`	`addVec3(float[] result, float[] v1, float[] v2)` Adds two vectors, result = v1 + v2
`static float`	`angleVec3(float[] vec1, float[] vec2)` Return the angle between to vectors in radians
`static float`	`area(ArrayList<? extends Vert2fImmutable> vertices)` Computes the area of a list of vertices to check if ccw
`static boolean`	`ccw(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c)` Check if points are in ccw order
`static float[]`	`copyVec2(float[] dst, int dstOffset, float[] src, int srcOffset)` Copies a vector of length 2
`static float[]`	`copyVec3(float[] dst, int dstOffset, float[] src, int srcOffset)` Copies a vector of length 3
`static float[]`	`copyVec4(float[] dst, int dstOffset, float[] src, int srcOffset)` Copies a vector of length 4
`static float`	`cosAngleVec3(float[] vec1, float[] vec2)` Return the cosines of the angle between to vectors
`static float[]`	`crossVec3(float[] result, float[] v1, float[] v2)` cross product vec1 x vec2
`static float[]`	`crossVec3(float[] r, int r_offset, float[] v1, int v1_offset, float[] v2, int v2_offset)` cross product vec1 x vec2
`static float`	`determinantVec3(float[] a, float[] b, float[] c)` Return the determinant of 3 vectors
`static float`	`distSquareVec3(float[] v1, float[] v2)` Return the squared distance between the given two points described vector v1 and v2.
`static float`	`distVec3(float[] v1, float[] v2)` Return the distance between the given two points described vector v1 and v2.
`static float[]`	`divVec2(float[] result, float[] vector, float scale)` Divides a vector by param using given result float[], result = vector / scale
`static float[]`	`divVec2(float[] result, float[] vector, float[] scale)` Divides a vector by param using given result float[], result = vector / scale
`static float[]`	`divVec3(float[] result, float[] vector, float scale)` Divides a vector by param using given result float[], result = vector / scale
`static float[]`	`divVec3(float[] result, float[] vector, float[] scale)` Divides a vector by param using given result float[], result = vector / scale
`static float`	`dotVec3(float[] vec1, float[] vec2)` Return the dot product of two points
`static float[]`	`getNormalVec2(float[] result, float[] v1, float[] v2)`
`static float[]`	`getNormalVec3(float[] result, float[] v1, float[] v2, float[] v3, float[] tmp1Vec3, float[] tmp2Vec3)` Returns the 3d surface normal of a triangle given three vertices.
`static float[]`	`getPlaneVec3(float[] resultV4, float[] normalVec3, float[] pVec3)` Finds the plane equation of a plane given its normal and a point on the plane.
`static float[]`	`getPlaneVec3(float[] resultVec4, float[] v1, float[] v2, float[] v3, float[] temp1V3, float[] temp2V3)` This finds the plane equation of a triangle given three vertices.
`static VectorUtil.Winding`	`getWinding(ArrayList<? extends Vert2fImmutable> vertices)` Compute the general winding of the vertices
`static VectorUtil.Winding`	`getWinding(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c)` Compute the winding of given points
`static boolean`	`isCollinearVec3(float[] v1, float[] v2, float[] v3)` Check if three vertices are colliniear
`static boolean`	`isInCircleVec2(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d)` Check if vertices in triangle circumcircle
`static boolean`	`isInTriangleVec3(float[] a, float[] b, float[] c, float[] p, float[] ac, float[] ab, float[] ap)` Check if a vertex is in triangle using barycentric coordinates computation.
`static boolean`	`isVec2Equal(float[] vec1, int vec1Offset, float[] vec2, int vec2Offset)` Return true if both vectors are equal w/o regarding an epsilon.
`static boolean`	`isVec2Equal(float[] vec1, int vec1Offset, float[] vec2, int vec2Offset, float epsilon)` Return true if both vectors are equal, i.e.
`static boolean`	`isVec2Zero(float[] vec, int vecOffset)` Return true if vector is zero, no `FloatUtil.EPSILON` is taken into consideration.
`static boolean`	`isVec2Zero(float[] vec, int vecOffset, float epsilon)` Return true if vector is zero, i.e.
`static boolean`	`isVec3Equal(float[] vec1, int vec1Offset, float[] vec2, int vec2Offset)` Return true if both vectors are equal w/o regarding an epsilon.
`static boolean`	`isVec3Equal(float[] vec1, int vec1Offset, float[] vec2, int vec2Offset, float epsilon)` Return true if both vectors are equal, i.e.
`static boolean`	`isVec3InTriangle3(float[] a, float[] b, float[] c, float[] p1, float[] p2, float[] p3, float[] tmpAC, float[] tmpAB, float[] tmpAP)` Check if one of three vertices are in triangle using barycentric coordinates computation.
`static boolean`	`isVec3InTriangle3(float[] a, float[] b, float[] c, float[] p1, float[] p2, float[] p3, float[] tmpAC, float[] tmpAB, float[] tmpAP, float epsilon)` Check if one of three vertices are in triangle using barycentric coordinates computation, using given epsilon for comparison.
`static boolean`	`isVec3Zero(float[] vec, int vecOffset)` Return true if vector is zero, no `FloatUtil.EPSILON` is taken into consideration.
`static boolean`	`isVec3Zero(float[] vec, int vecOffset, float epsilon)` Return true if vector is zero, i.e.
`static boolean`	`isZero(float x, float y, float epsilon)` Return true if all two vector components are zero, i.e.
`static boolean`	`isZero(float x, float y, float z, float epsilon)` Return true if all three vector components are zero, i.e.
`static float[]`	`line2lineIntersection(float[] result, Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d)` Compute intersection between two lines
`static float[]`	`line2PlaneIntersection(float[] result, Ray ray, float[] plane, float epsilon)` Return intersection of an infinite line with a plane if exists, otherwise null.
`static float`	`mid(float p1, float p2)` Calculate the midpoint of two values
`static float[]`	`midVec3(float[] result, float[] p1, float[] p2)` Calculate the midpoint of two points
`static float[]`	`mulColMat4Vec3(float[] result, float[] colMatrix, float[] vec)` Multiplication of column-major 4x4 matrix with vector
`static float[]`	`mulRowMat4Vec3(float[] result, float[] rawMatrix, float[] vec)` Matrix Vector multiplication
`static float[]`	`normalizeVec2(float[] vector)` Normalize a vector in place
`static float[]`	`normalizeVec2(float[] result, float[] vector)` Normalize a vector
`static float[]`	`normalizeVec3(float[] vector)` Normalize a vector in place
`static float[]`	`normalizeVec3(float[] result, float[] vector)` Normalize a vector
`static float[]`	`normalizeVec3(float[] vector, int offset)` Normalize a vector in place
`static float`	`normSquareVec2(float[] vec)` Return the squared length of a vector, a.k.a the squared norm or squared magnitude
`static float`	`normSquareVec2(float[] vec, int offset)` Return the squared length of a vector, a.k.a the squared norm or squared magnitude
`static float`	`normSquareVec3(float[] vec)` Return the squared length of a vector, a.k.a the squared norm or squared magnitude
`static float`	`normSquareVec3(float[] vec, int offset)` Return the squared length of a vector, a.k.a the squared norm or squared magnitude
`static float`	`normVec2(float[] vec)` Return the length of a vector, a.k.a the norm or magnitude
`static float`	`normVec3(float[] vec)` Return the length of a vector, a.k.a the norm or magnitude
`static float[]`	`scaleVec2(float[] result, float[] vector, float scale)` Scales a vector by param using given result float[], result = vector * scale
`static float[]`	`scaleVec2(float[] result, float[] vector, float[] scale)` Scales a vector by param using given result float[], result = vector * scale
`static float[]`	`scaleVec3(float[] result, float[] vector, float scale)` Scales a vector by param using given result float[], result = vector * scale
`static float[]`	`scaleVec3(float[] result, float[] vector, float[] scale)` Scales a vector by param using given result float[], result = vector * scale
`static float[]`	`seg2SegIntersection(float[] result, Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d)` Compute intersection between two segments
`static float[]`	`subVec2(float[] result, float[] v1, float[] v2)` Subtracts two vectors, result = v1 - v2
`static float[]`	`subVec3(float[] result, float[] v1, float[] v2)` Subtracts two vectors, result = v1 - v2
`static boolean`	`testSeg2SegIntersection(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d)` Compute intersection between two segments
`static boolean`	`testSeg2SegIntersection(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d, float epsilon)` Compute intersection between two segments, using given epsilon for comparison.
`static boolean`	`testTri2SegIntersection(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d, Vert2fImmutable e)` Check if a segment intersects with a triangle
`static boolean`	`testTri2SegIntersection(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c, Vert2fImmutable d, Vert2fImmutable e, float epsilon)` Check if a segment intersects with a triangle, using given epsilon for comparison.
`static float`	`triAreaVec2(float[] A, float[] B, float[] C)` Computes oriented area of a triangle
`static float`	`triAreaVec2(Vert2fImmutable a, Vert2fImmutable b, Vert2fImmutable c)` Computes oriented area of a triangle

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - VEC3_ONE
```
public static final float[] VEC3_ONE
```
  - VEC3_ZERO
```
public static final float[] VEC3_ZERO
```
  - VEC3_UNIT_Y
```
public static final float[] VEC3_UNIT_Y
```
  - VEC3_UNIT_Y_NEG
```
public static final float[] VEC3_UNIT_Y_NEG
```
  - VEC3_UNIT_Z
```
public static final float[] VEC3_UNIT_Z
```
  - VEC3_UNIT_Z_NEG
```
public static final float[] VEC3_UNIT_Z_NEG
```
- Constructor Detail
  - VectorUtil
```
public VectorUtil()
```
- Method Detail
  - copyVec2
```
public static float[] copyVec2(float[] dst,
               int dstOffset,
               float[] src,
               int srcOffset)
```
    Copies a vector of length 2
    
    Parameters:
    dst - output vector
    dstOffset - offset of dst in array
    src - input vector
    srcOffset - offset of src in array
    
    Returns:
    copied output vector for chaining
  - copyVec3
```
public static float[] copyVec3(float[] dst,
               int dstOffset,
               float[] src,
               int srcOffset)
```
    Copies a vector of length 3
    
    Parameters:
    dst - output vector
    dstOffset - offset of dst in array
    src - input vector
    srcOffset - offset of src in array
    
    Returns:
    copied output vector for chaining
  - copyVec4
```
public static float[] copyVec4(float[] dst,
               int dstOffset,
               float[] src,
               int srcOffset)
```
    Copies a vector of length 4
    
    Parameters:
    dst - output vector
    dstOffset - offset of dst in array
    src - input vector
    srcOffset - offset of src in array
    
    Returns:
    copied output vector for chaining
  - isVec2Equal
```
public static boolean isVec2Equal(float[] vec1,
                  int vec1Offset,
                  float[] vec2,
                  int vec2Offset)
```
    Return true if both vectors are equal w/o regarding an epsilon.
    Implementation uses FloatUtil.isEqual(float, float), see API doc for details.
  - isVec3Equal
```
public static boolean isVec3Equal(float[] vec1,
                  int vec1Offset,
                  float[] vec2,
                  int vec2Offset)
```
    Return true if both vectors are equal w/o regarding an epsilon.
    Implementation uses FloatUtil.isEqual(float, float), see API doc for details.
  - isVec2Equal
```
public static boolean isVec2Equal(float[] vec1,
                  int vec1Offset,
                  float[] vec2,
                  int vec2Offset,
                  float epsilon)
```
    Return true if both vectors are equal, i.e. their absolute delta < epsilon.
    Implementation uses FloatUtil.isEqual(float, float, float), see API doc for details.
  - isVec3Equal
```
public static boolean isVec3Equal(float[] vec1,
                  int vec1Offset,
                  float[] vec2,
                  int vec2Offset,
                  float epsilon)
```
    Return true if both vectors are equal, i.e. their absolute delta < epsilon.
    Implementation uses FloatUtil.isEqual(float, float, float), see API doc for details.
  - isVec2Zero
```
public static boolean isVec2Zero(float[] vec,
                 int vecOffset)
```
    Return true if vector is zero, no FloatUtil.EPSILON is taken into consideration.
  - isVec3Zero
```
public static boolean isVec3Zero(float[] vec,
                 int vecOffset)
```
    Return true if vector is zero, no FloatUtil.EPSILON is taken into consideration.
  - isVec2Zero
```
public static boolean isVec2Zero(float[] vec,
                 int vecOffset,
                 float epsilon)
```
    Return true if vector is zero, i.e. it's absolute components < epsilon.
    Implementation uses FloatUtil.isZero(float, float), see API doc for details.
  - isVec3Zero
```
public static boolean isVec3Zero(float[] vec,
                 int vecOffset,
                 float epsilon)
```
    Return true if vector is zero, i.e. it's absolute components < epsilon.
    Implementation uses FloatUtil.isZero(float, float), see API doc for details.
  - isZero
```
public static boolean isZero(float x,
             float y,
             float epsilon)
```
    Return true if all two vector components are zero, i.e. it's their absolute value < epsilon.
    Implementation uses FloatUtil.isZero(float, float), see API doc for details.
  - isZero
```
public static boolean isZero(float x,
             float y,
             float z,
             float epsilon)
```
    Return true if all three vector components are zero, i.e. it's their absolute value < epsilon.
    Implementation uses FloatUtil.isZero(float, float), see API doc for details.
  - distSquareVec3
```
public static float distSquareVec3(float[] v1,
                   float[] v2)
```
    Return the squared distance between the given two points described vector v1 and v2.
    When comparing the relative distance between two points it is usually sufficient to compare the squared distances, thus avoiding an expensive square root operation.
  - distVec3
```
public static float distVec3(float[] v1,
             float[] v2)
```
    Return the distance between the given two points described vector v1 and v2.
  - dotVec3
```
public static float dotVec3(float[] vec1,
            float[] vec2)
```
    Return the dot product of two points
    
    Parameters:
    vec1 - vector 1
    vec2 - vector 2
    
    Returns:
    the dot product as float
  - cosAngleVec3
```
public static float cosAngleVec3(float[] vec1,
                 float[] vec2)
```
    Return the cosines of the angle between to vectors
    
    Parameters:
    vec1 - vector 1
    vec2 - vector 2
  - angleVec3
```
public static float angleVec3(float[] vec1,
              float[] vec2)
```
    Return the angle between to vectors in radians
    
    Parameters:
    vec1 - vector 1
    vec2 - vector 2
  - normSquareVec2
```
public static float normSquareVec2(float[] vec)
```
    Return the squared length of a vector, a.k.a the squared norm or squared magnitude
  - normSquareVec2
```
public static float normSquareVec2(float[] vec,
                   int offset)
```
    Return the squared length of a vector, a.k.a the squared norm or squared magnitude
  - normSquareVec3
```
public static float normSquareVec3(float[] vec)
```
    Return the squared length of a vector, a.k.a the squared norm or squared magnitude
  - normSquareVec3
```
public static float normSquareVec3(float[] vec,
                   int offset)
```
    Return the squared length of a vector, a.k.a the squared norm or squared magnitude
  - normVec2
```
public static float normVec2(float[] vec)
```
    Return the length of a vector, a.k.a the norm or magnitude
  - normVec3
```
public static float normVec3(float[] vec)
```
    Return the length of a vector, a.k.a the norm or magnitude
  - normalizeVec2
```
public static float[] normalizeVec2(float[] result,
                    float[] vector)
```
    Normalize a vector
    
    Parameters:
    result - output vector, may be vector (in-place)
    vector - input vector
    
    Returns:
    normalized output vector
  - normalizeVec2
```
public static float[] normalizeVec2(float[] vector)
```
    Normalize a vector in place
    
    Parameters:
    vector - input vector
    
    Returns:
    normalized output vector
  - normalizeVec3
```
public static float[] normalizeVec3(float[] result,
                    float[] vector)
```
    Normalize a vector
    
    Parameters:
    result - output vector, may be vector (in-place)
    vector - input vector
    
    Returns:
    normalized output vector
  - normalizeVec3
```
public static float[] normalizeVec3(float[] vector)
```
    Normalize a vector in place
    
    Parameters:
    vector - input vector
    
    Returns:
    normalized output vector
  - normalizeVec3
```
public static float[] normalizeVec3(float[] vector,
                    int offset)
```
    Normalize a vector in place
    
    Parameters:
    vector - input vector
    
    Returns:
    normalized output vector
  - scaleVec2
```
public static float[] scaleVec2(float[] result,
                float[] vector,
                float scale)
```
    Scales a vector by param using given result float[], result = vector * scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - single scale constant for all vector components
    
    Returns:
    result vector for chaining
  - scaleVec3
```
public static float[] scaleVec3(float[] result,
                float[] vector,
                float scale)
```
    Scales a vector by param using given result float[], result = vector * scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - single scale constant for all vector components
    
    Returns:
    result vector for chaining
  - scaleVec3
```
public static float[] scaleVec3(float[] result,
                float[] vector,
                float[] scale)
```
    Scales a vector by param using given result float[], result = vector * scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - 3 component scale constant for each vector component
    
    Returns:
    result vector for chaining
  - scaleVec2
```
public static float[] scaleVec2(float[] result,
                float[] vector,
                float[] scale)
```
    Scales a vector by param using given result float[], result = vector * scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - 2 component scale constant for each vector component
    
    Returns:
    result vector for chaining
  - divVec2
```
public static float[] divVec2(float[] result,
              float[] vector,
              float scale)
```
    Divides a vector by param using given result float[], result = vector / scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - single scale constant for all vector components
    
    Returns:
    result vector for chaining
  - divVec3
```
public static float[] divVec3(float[] result,
              float[] vector,
              float scale)
```
    Divides a vector by param using given result float[], result = vector / scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - single scale constant for all vector components
    
    Returns:
    result vector for chaining
  - divVec3
```
public static float[] divVec3(float[] result,
              float[] vector,
              float[] scale)
```
    Divides a vector by param using given result float[], result = vector / scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - 3 component scale constant for each vector component
    
    Returns:
    result vector for chaining
  - divVec2
```
public static float[] divVec2(float[] result,
              float[] vector,
              float[] scale)
```
    Divides a vector by param using given result float[], result = vector / scale
    
    Parameters:
    result - vector for the result, may be vector (in-place)
    vector - input vector
    scale - 2 component scale constant for each vector component
    
    Returns:
    result vector for chaining
  - addVec2
```
public static float[] addVec2(float[] result,
              float[] v1,
              float[] v2)
```
    Adds two vectors, result = v1 + v2
    
    Parameters:
    result - float[2] result vector, may be either v1 or v2 (in-place)
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    result vector for chaining
  - addVec3
```
public static float[] addVec3(float[] result,
              float[] v1,
              float[] v2)
```
    Adds two vectors, result = v1 + v2
    
    Parameters:
    result - float[3] result vector, may be either v1 or v2 (in-place)
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    result vector for chaining
  - subVec2
```
public static float[] subVec2(float[] result,
              float[] v1,
              float[] v2)
```
    Subtracts two vectors, result = v1 - v2
    
    Parameters:
    result - float[2] result vector, may be either v1 or v2 (in-place)
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    result vector for chaining
  - subVec3
```
public static float[] subVec3(float[] result,
              float[] v1,
              float[] v2)
```
    Subtracts two vectors, result = v1 - v2
    
    Parameters:
    result - float[3] result vector, may be either v1 or v2 (in-place)
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    result vector for chaining
  - crossVec3
```
public static float[] crossVec3(float[] result,
                float[] v1,
                float[] v2)
```
    cross product vec1 x vec2
    
    Parameters:
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    the resulting vector
  - crossVec3
```
public static float[] crossVec3(float[] r,
                int r_offset,
                float[] v1,
                int v1_offset,
                float[] v2,
                int v2_offset)
```
    cross product vec1 x vec2
    
    Parameters:
    v1 - vector 1
    v2 - vector 2
    
    Returns:
    the resulting vector
  - mulColMat4Vec3
```
public static float[] mulColMat4Vec3(float[] result,
                     float[] colMatrix,
                     float[] vec)
```
    Multiplication of column-major 4x4 matrix with vector
    
    Parameters:
    colMatrix - column matrix (4x4)
    vec - vector(x,y,z)
    
    Returns:
    result
  - mulRowMat4Vec3
```
public static float[] mulRowMat4Vec3(float[] result,
                     float[] rawMatrix,
                     float[] vec)
```
    Matrix Vector multiplication
    
    Parameters:
    rawMatrix - column matrix (4x4)
    vec - vector(x,y,z)
    
    Returns:
    result
  - mid
```
public static float mid(float p1,
        float p2)
```
    Calculate the midpoint of two values
    
    Parameters:
    p1 - first value
    p2 - second vale
    
    Returns:
    midpoint
  - midVec3
```
public static float[] midVec3(float[] result,
              float[] p1,
              float[] p2)
```
    Calculate the midpoint of two points
    
    Parameters:
    p1 - first point vector
    p2 - second point vector
    
    Returns:
    midpoint
  - determinantVec3
```
public static float determinantVec3(float[] a,
                    float[] b,
                    float[] c)
```
    Return the determinant of 3 vectors
    
    Parameters:
    a - vector 1
    b - vector 2
    c - vector 3
    
    Returns:
    the determinant value
  - isCollinearVec3
```
public static boolean isCollinearVec3(float[] v1,
                      float[] v2,
                      float[] v3)
```
    Check if three vertices are colliniear
    
    Parameters:
    v1 - vertex 1
    v2 - vertex 2
    v3 - vertex 3
    
    Returns:
    true if collinear, false otherwise
  - isInCircleVec2
```
public static boolean isInCircleVec2(Vert2fImmutable a,
                     Vert2fImmutable b,
                     Vert2fImmutable c,
                     Vert2fImmutable d)
```
    Check if vertices in triangle circumcircle
    
    Parameters:
    a - triangle vertex 1
    b - triangle vertex 2
    c - triangle vertex 3
    d - vertex in question
    
    Returns:
    true if the vertex d is inside the circle defined by the vertices a, b, c. from paper by Guibas and Stolfi (1985).
  - triAreaVec2
```
public static float triAreaVec2(Vert2fImmutable a,
                Vert2fImmutable b,
                Vert2fImmutable c)
```
    Computes oriented area of a triangle
    
    Parameters:
    a - first vertex
    b - second vertex
    c - third vertex
    
    Returns:
    compute twice the area of the oriented triangle (a,b,c), the area is positive if the triangle is oriented counterclockwise.
  - triAreaVec2
```
public static float triAreaVec2(float[] A,
                float[] B,
                float[] C)
```
    Computes oriented area of a triangle
    
    Parameters:
    A - first vertex
    B - second vertex
    C - third vertex
    
    Returns:
    compute twice the area of the oriented triangle (a,b,c), the area is positive if the triangle is oriented counterclockwise.
  - isInTriangleVec3
```
public static boolean isInTriangleVec3(float[] a,
                       float[] b,
                       float[] c,
                       float[] p,
                       float[] ac,
                       float[] ab,
                       float[] ap)
```
    Check if a vertex is in triangle using barycentric coordinates computation.
    
    Parameters:
    a - first triangle vertex
    b - second triangle vertex
    c - third triangle vertex
    p - the vertex in question
    
    Returns:
    true if p is in triangle (a, b, c), false otherwise.
  - isVec3InTriangle3
```
public static boolean isVec3InTriangle3(float[] a,
                        float[] b,
                        float[] c,
                        float[] p1,
                        float[] p2,
                        float[] p3,
                        float[] tmpAC,
                        float[] tmpAB,
                        float[] tmpAP)
```
    Check if one of three vertices are in triangle using barycentric coordinates computation.
    
    Parameters:
    a - first triangle vertex
    b - second triangle vertex
    c - third triangle vertex
    p1 - the vertex in question
    p2 - the vertex in question
    p3 - the vertex in question
    tmpAC -
    tmpAB -
    tmpAP -
    
    Returns:
    true if p1 or p2 or p3 is in triangle (a, b, c), false otherwise.
  - isVec3InTriangle3
```
public static boolean isVec3InTriangle3(float[] a,
                        float[] b,
                        float[] c,
                        float[] p1,
                        float[] p2,
                        float[] p3,
                        float[] tmpAC,
                        float[] tmpAB,
                        float[] tmpAP,
                        float epsilon)
```
    Check if one of three vertices are in triangle using barycentric coordinates computation, using given epsilon for comparison.
    
    Parameters:
    a - first triangle vertex
    b - second triangle vertex
    c - third triangle vertex
    p1 - the vertex in question
    p2 - the vertex in question
    p3 - the vertex in question
    tmpAC -
    tmpAB -
    tmpAP -
    
    Returns:
    true if p1 or p2 or p3 is in triangle (a, b, c), false otherwise.
  - ccw
```
public static boolean ccw(Vert2fImmutable a,
          Vert2fImmutable b,
          Vert2fImmutable c)
```
    Check if points are in ccw order
    
    Parameters:
    a - first vertex
    b - second vertex
    c - third vertex
    
    Returns:
    true if the points a,b,c are in a ccw order
  - getWinding
```
public static VectorUtil.Winding getWinding(Vert2fImmutable a,
                            Vert2fImmutable b,
                            Vert2fImmutable c)
```
    Compute the winding of given points
    
    Parameters:
    a - first vertex
    b - second vertex
    c - third vertex
    
    Returns:
    Winding
  - area
```
public static float area(ArrayList<? extends Vert2fImmutable> vertices)
```
    Computes the area of a list of vertices to check if ccw
    
    Parameters:
    vertices -
    
    Returns:
    positive area if ccw else negative area value
  - getWinding
```
public static VectorUtil.Winding getWinding(ArrayList<? extends Vert2fImmutable> vertices)
```
    Compute the general winding of the vertices
    
    Parameters:
    vertices - array of Vertices
    
    Returns:
    CCW or CW VectorUtil.Winding
  - getNormalVec2
```
public static float[] getNormalVec2(float[] result,
                    float[] v1,
                    float[] v2)
```
    Parameters:
    result - vec2 result for normal
    v1 - vec2
    v2 - vec2
    
    Returns:
    result for chaining
  - getNormalVec3
```
public static float[] getNormalVec3(float[] result,
                    float[] v1,
                    float[] v2,
                    float[] v3,
                    float[] tmp1Vec3,
                    float[] tmp2Vec3)
```
    Returns the 3d surface normal of a triangle given three vertices.
    
    Parameters:
    result - vec3 result for normal
    v1 - vec3
    v2 - vec3
    v3 - vec3
    tmp1Vec3 - temp vec3
    tmp2Vec3 - temp vec3
    
    Returns:
    result for chaining
  - getPlaneVec3
```
public static float[] getPlaneVec3(float[] resultV4,
                   float[] normalVec3,
                   float[] pVec3)
```
    Finds the plane equation of a plane given its normal and a point on the plane.
    
    Parameters:
    resultV4 - vec4 plane equation
    normalVec3 -
    pVec3 -
    
    Returns:
    result for chaining
  - getPlaneVec3
```
public static float[] getPlaneVec3(float[] resultVec4,
                   float[] v1,
                   float[] v2,
                   float[] v3,
                   float[] temp1V3,
                   float[] temp2V3)
```
    This finds the plane equation of a triangle given three vertices.
    
    Parameters:
    resultVec4 - vec4 plane equation
    v1 - vec3
    v2 - vec3
    v3 - vec3
    temp1V3 -
    temp2V3 -
    
    Returns:
    result for chaining
  - line2PlaneIntersection
```
public static float[] line2PlaneIntersection(float[] result,
                             Ray ray,
                             float[] plane,
                             float epsilon)
```
    Return intersection of an infinite line with a plane if exists, otherwise null.
    Thanks to Norman Vine -- nhv@yahoo.com (with hacks by Steve)
    
    Parameters:
    result - vec3 result buffer for intersecting coords
    ray - here representing an infinite line, origin and direction.
    plane - vec4 plane equation
    epsilon -
    
    Returns:
    resulting intersecting if exists, otherwise null
  - seg2SegIntersection
```
public static float[] seg2SegIntersection(float[] result,
                          Vert2fImmutable a,
                          Vert2fImmutable b,
                          Vert2fImmutable c,
                          Vert2fImmutable d)
```
    Compute intersection between two segments
    
    Parameters:
    a - vertex 1 of first segment
    b - vertex 2 of first segment
    c - vertex 1 of second segment
    d - vertex 2 of second segment
    
    Returns:
    the intersection coordinates if the segments intersect, otherwise returns null
  - testSeg2SegIntersection
```
public static boolean testSeg2SegIntersection(Vert2fImmutable a,
                              Vert2fImmutable b,
                              Vert2fImmutable c,
                              Vert2fImmutable d)
```
    Compute intersection between two segments
    
    Parameters:
    a - vertex 1 of first segment
    b - vertex 2 of first segment
    c - vertex 1 of second segment
    d - vertex 2 of second segment
    
    Returns:
    true if the segments intersect, otherwise returns false
  - testSeg2SegIntersection
```
public static boolean testSeg2SegIntersection(Vert2fImmutable a,
                              Vert2fImmutable b,
                              Vert2fImmutable c,
                              Vert2fImmutable d,
                              float epsilon)
```
    Compute intersection between two segments, using given epsilon for comparison.
    
    Parameters:
    a - vertex 1 of first segment
    b - vertex 2 of first segment
    c - vertex 1 of second segment
    d - vertex 2 of second segment
    
    Returns:
    true if the segments intersect, otherwise returns false
  - line2lineIntersection
```
public static float[] line2lineIntersection(float[] result,
                            Vert2fImmutable a,
                            Vert2fImmutable b,
                            Vert2fImmutable c,
                            Vert2fImmutable d)
```
    Compute intersection between two lines
    
    Parameters:
    a - vertex 1 of first line
    b - vertex 2 of first line
    c - vertex 1 of second line
    d - vertex 2 of second line
    
    Returns:
    the intersection coordinates if the lines intersect, otherwise returns null
  - testTri2SegIntersection
```
public static boolean testTri2SegIntersection(Vert2fImmutable a,
                              Vert2fImmutable b,
                              Vert2fImmutable c,
                              Vert2fImmutable d,
                              Vert2fImmutable e)
```
    Check if a segment intersects with a triangle
    
    Parameters:
    a - vertex 1 of the triangle
    b - vertex 2 of the triangle
    c - vertex 3 of the triangle
    d - vertex 1 of first segment
    e - vertex 2 of first segment
    
    Returns:
    true if the segment intersects at least one segment of the triangle, false otherwise
  - testTri2SegIntersection
```
public static boolean testTri2SegIntersection(Vert2fImmutable a,
                              Vert2fImmutable b,
                              Vert2fImmutable c,
                              Vert2fImmutable d,
                              Vert2fImmutable e,
                              float epsilon)
```
    Check if a segment intersects with a triangle, using given epsilon for comparison.
    
    Parameters:
    a - vertex 1 of the triangle
    b - vertex 2 of the triangle
    c - vertex 3 of the triangle
    d - vertex 1 of first segment
    e - vertex 2 of first segment
    
    Returns:
    true if the segment intersects at least one segment of the triangle, false otherwise

Class VectorUtil

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

VEC3_ONE

VEC3_ZERO

VEC3_UNIT_Y

VEC3_UNIT_Y_NEG

VEC3_UNIT_Z

VEC3_UNIT_Z_NEG

Constructor Detail

VectorUtil

Method Detail

copyVec2

copyVec3

copyVec4

isVec2Equal

isVec3Equal

isVec2Equal

isVec3Equal

isVec2Zero

isVec3Zero

isVec2Zero

isVec3Zero

isZero

isZero

distSquareVec3

distVec3

dotVec3

cosAngleVec3

angleVec3

normSquareVec2

normSquareVec2

normSquareVec3

normSquareVec3

normVec2

normVec3

normalizeVec2

normalizeVec2

normalizeVec3

normalizeVec3

normalizeVec3

scaleVec2

scaleVec3

scaleVec3

scaleVec2

divVec2

divVec3

divVec3

divVec2

addVec2

addVec3

subVec2

subVec3

crossVec3

crossVec3

mulColMat4Vec3

mulRowMat4Vec3

mid

midVec3

determinantVec3

isCollinearVec3

isInCircleVec2

triAreaVec2

triAreaVec2

isInTriangleVec3

isVec3InTriangle3

isVec3InTriangle3

ccw

getWinding

area

getWinding

getNormalVec2

getNormalVec3

getPlaneVec3

getPlaneVec3

line2PlaneIntersection