Package com.io7m.jtensors.core.parameterized.vectors

Class PVectors2F

java.lang.Object
com.io7m.jtensors.core.parameterized.vectors.PVectors2F
public final class PVectors2F extends Object

Functions over PVector2F values.

See "Mathematics for 3D Game Programming and Computer Graphics" 2nd Ed for the derivations of most of the code in this class (ISBN: 1-58450-277-0).

Since:
8.0.0

  • Method Details

    • absolute

      public static <T> PVector2F<T> absolute(PVector2F<T> v0)
      Calculate the absolute of v0.
      Type Parameters:
      T - A phantom type parameter * @param v0 The vector
      Returns:
      (abs v0.x, abs v0.y)

    • add

      public static <T> PVector2F<T> add(PVector2F<T> v0, PVector2F<T> v1)
      Add v0 to v1.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      Returns:
      (v0.x + v1.x, v0.y + v1.y)

    • multiply

      public static <T> PVector2F<T> multiply(PVector2F<T> v0, PVector2F<T> v1)
      Multiply v0 by v1.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      Returns:
      (v0.x * v1.x, v0.y * v1.y)
      Since:
      10.0.0

    • addScaled

      public static <T> PVector2F<T> addScaled(PVector2F<T> v0, PVector2F<T> v1, double r)
      Add v0 to v1 * r.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      r - The scaling value
      Returns:
      (v0.x + (v1.x * r), v0.y + (v1.y * r))

    • angle

      public static <T> double angle(PVector2F<T> v0, PVector2F<T> v1)
      Calculate the angle between the vectors v0 and v1 in radians.
      Type Parameters:
      T - A phantom type parameter * @return The angle between the two vectors, in radians.
      Parameters:
      v0 - The left input vector
      v1 - The right input vector

    • clamp

      public static <T> PVector2F<T> clamp(PVector2F<T> v, PVector2F<T> v_min, PVector2F<T> v_max)
      Clamp the values in v by v_min and v_max.
      Type Parameters:
      T - A phantom type parameter * @param v The source vector
      Parameters:
      v_min - The minimum vector
      v_max - The maximum vector
      Returns:
      (max(min(v.x, v_max.x()), v_min.x()), max(min(v.y, v_max.y()), v_min.y()))

    • distance

      public static <T> double distance(PVector2F<T> v0, PVector2F<T> v1)
      Calculate the distance between v0 and v1.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      Returns:
      The distance between v0 and v1.

    • dotProduct

      public static <T> double dotProduct(PVector2F<T> v0, PVector2F<T> v1)
      Calculate the scalar product of the vectors v0 and v1.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      Returns:
      The scalar product of the two vectors

    • interpolateLinear

      public static <T> PVector2F<T> interpolateLinear(PVector2F<T> v0, PVector2F<T> v1, double alpha)

      Linearly interpolate between v0 and v1 by the amount alpha.

      The alpha parameter controls the degree of interpolation, such that:

      • interpolateLinear(v0, v1, 0.0) = v0
      • interpolateLinear(v0, v1, 1.0) = v1
      Type Parameters:
      T - A phantom type parameter * @return ((1 - alpha) * v0) + (alpha * v1)
      Parameters:
      v0 - The left input vector
      v1 - The right input vector
      alpha - The interpolation value in the range [0, 1]

    • interpolateBilinear

      public static <T> PVector2F<T> interpolateBilinear(PVector2F<T> x0y0, PVector2F<T> x1y0, PVector2F<T> x0y1, PVector2F<T> x1y1, double px, double py)

      Bilinearly interpolate between x0y0, x1y0, x0y1, x1y1.

      The px and py parameters control the degree of interpolation, such that:

      • interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 0.0) = x0y0
      • interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 0.0) = x1y0
      • interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 1.0) = x0y1
      • interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 1.0) = x1y1
      Type Parameters:
      T - A phantom type parameter * @return The bilinearly interpolated value
      Parameters:
      x0y0 - The top left input vector
      x1y0 - The top right input vector
      x0y1 - The bottom left input vector
      x1y1 - The bottom right input vector
      px - The X interpolation value in the range [0, 1]
      py - The Y interpolation value in the range [0, 1]

    • magnitudeSquared

      public static <T> double magnitudeSquared(PVector2F<T> v0)
      Calculate the squared magnitude of the vector v0.
      Type Parameters:
      T - A phantom type parameter * @param v0 The vector
      Returns:
      The squared magnitude of the vector

    • magnitude

      public static <T> double magnitude(PVector2F<T> v0)
      Calculate the magnitude of the vector v0.
      Type Parameters:
      T - A phantom type parameter * @param v0 The vector
      Returns:
      The magnitude of the vector

    • negate

      public static <T> PVector2F<T> negate(PVector2F<T> v)
      Calculate the negation of v.
      Type Parameters:
      T - A phantom type parameter * @param v The vector
      Returns:
      (-v.x, -v.y)

    • normalize

      public static <T> PVector2F<T> normalize(PVector2F<T> v0)

      Normalize the vector v0.

      If the magnitude of the vector is zero, the function returns v0.

      Type Parameters:
      T - A phantom type parameter * @param v0 The vector
      Returns:
      A normalized copy of v0

    • scale

      public static <T> PVector2F<T> scale(PVector2F<T> v0, double r)
      Scale v0 by r.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      r - The scaling value
      Returns:
      (v0.x * r, v0.y * r)

    • subtract

      public static <T> PVector2F<T> subtract(PVector2F<T> v0, PVector2F<T> v1)
      Subtract v1 from v0.
      Type Parameters:
      T - A phantom type parameter * @param v0 The left vector
      Parameters:
      v1 - The right vector
      Returns:
      (v0.x - v1.x, v0.y - v1.y)

    • zero

      public static <T> PVector2F<T> zero()
      The zero vector.
      Type Parameters:
      T - A phantom type parameter
      Returns:
      (0, 0)

    • toUnparameterized

      public static <A> Vector2F toUnparameterized(PVector2F<A> v)
      Type Parameters:
      A - A phantom type parameter (possibly representing a coordinate system)
      Parameters:
      v - The input vector
      Returns:
      A vector equal to m but without type parameters

    • toParameterized

      public static <A> PVector2F<A> toParameterized(Vector2F v)
      Type Parameters:
      A - A phantom type parameter (possibly representing a coordinate system)
      Parameters:
      v - The input vector
      Returns:
      A vector equal to v with type parameters