Class PZMath

java.lang.Object
zombie.core.math.PZMath
public final class PZMath extends Object

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static interface 
    PZMath.FloatGet<E>
     
    static interface 
    PZMath.FloatSet<E>
     
    static enum 
    PZMath.SideOfLine
     

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final float
    degToRads
    Conversion ratios, Degrees to Radians and back
    static final float
    halfPI
     
    static final long
    microsToNanos
     
    static final long
    millisToMicros
     
    static final float
    PI
    The double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.
    static final float
    PI2
     
    static final float
    radToDegs
     
    static final long
    secondsToMillis
     
    static long
    secondsToNanos
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    PZMath()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static float
    abs(float val)
     
    static float
    acosf(float a)
     
    static float
    almostIdentity(float x, float m, float n)
    Almost Identity Imagine you don't want to modify a signal unless it's drops to zero or close to it, in which case you want to replace the value with a small possitive constant.
    static float
    almostUnitIdentity(float x)
    Almost Unit Identity This is a near-identiy function that maps the unit interval into itself.
    static float
    angleBetween(float in_ax, float in_ay, float in_bx, float in_by)
     
    static float
    angleBetween(Vector2 va, Vector2 vb)
     
    static float
    angleBetweenNormalized(float ax, float bx, float ay, float by)
     
    static float
    c_lerp(float src, float dest, float alpha)
     
    static float
    calculateBearing(Vector3 in_fromPosition, Vector2 in_fromForward, Vector3 in_toPosition)
     
    static boolean
    canParseFloat(String varStr)
     
    static float
    ceil(float val)
     
    static double
    clamp(double val, double min, double max)
     
    static float
    clamp(float val, float min, float max)
    Result is clamped between min and max.
    static int
    clamp(int val, int min, int max)
    Result is clamped between min and max.
    static long
    clamp(long val, long min, long max)
     
    static float
    clamp_01(float val)
     
    static double
    clampDouble_01(double val)
     
    static float
    clampFloat(float val, float min, float max)
     
    static double
    closestPointOnLineSegment(float x1, float y1, float x2, float y2, float px, float py, double epsilon, org.joml.Vector2f out)
     
    static double
    closestPointsOnLineSegments(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, org.joml.Vector2f p1, org.joml.Vector2f p2)
     
    static Vector3
    closestVector3(float lx0, float ly0, float lz0, float lx1, float ly1, float lz1, float x, float y, float z)
     
    static org.lwjgl.util.vector.Matrix4f
    convertMatrix(org.joml.Matrix4f src, org.lwjgl.util.vector.Matrix4f dst)
     
    static org.joml.Matrix4f
    convertMatrix(org.lwjgl.util.vector.Matrix4f src, org.joml.Matrix4f dst)
     
    static int
    coorddivision(int value, int divisor)
     
    static int
    coordmodulo(int value, int divisor)
     
    static float
    coordmodulof(float value, int divisor)
     
    static float
    degToRad(float degrees)
     
    static boolean
    equal(float a, float b)
     
    static boolean
    equal(float a, float b, float delta)
     
    static int
    fastfloor(double val)
     
    static int
    fastfloor(float val)
     
    static double
    floor(double val)
     
    static float
    floor(float val)
     
    static float
    frac(float val)
     
    static float
    gain(float x, float k)
    Gain Remapping the unit interval into the unit interval by expanding the sides and compressing the center, and keeping 1/2 mapped to 1/2, that can be done with the gain() function.
    static float
    getClosestAngle(float in_radsA, float in_radsB)
     
    static float
    getClosestAngleDegrees(float in_degsA, float in_degsB)
     
    static boolean
    intersectLineSegments(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, org.joml.Vector2f intersection)
     
    static float
    isLeft(float x0, float y0, float x1, float y1, float x2, float y2)
     
    static float
    lerp(float src, float dest, float alpha)
     
    static float
    lerp(float src, float dest, float alpha, LerpType lerpType)
     
    static org.lwjgl.util.vector.Vector3f
    lerp(org.lwjgl.util.vector.Vector3f out, org.lwjgl.util.vector.Vector3f a, org.lwjgl.util.vector.Vector3f b, float t)
     
    static Vector2
    lerp(Vector2 out, Vector2 a, Vector2 b, float t)
     
    static Vector3
    lerp(Vector3 out, Vector3 a, Vector3 b, float t)
     
    static float
    lerpAngle(float src, float dest, float alpha)
     
    static float
    lerpFunc_EaseInQuad(float x)
     
    static float
    lerpFunc_EaseOutInQuad(float x)
     
    static float
    lerpFunc_EaseOutQuad(float x)
     
    static float
    max(float a, float b)
     
    static float
    max(float a, float b, float c)
     
    static float
    max(float a, float b, float c, float d)
     
    static float
    max(float a, float b, float c, float d, float e)
     
    static int
    max(int a, int b)
     
    static int
    max(int a, int b, int c)
     
    static int
    max(int a, int b, int c, int d)
     
    static int
    max(int a, int b, int c, int d, int e)
     
    static float
    min(float a, float b)
     
    static float
    min(float a, float b, float c)
     
    static float
    min(float a, float b, float c, float d)
     
    static float
    min(float a, float b, float c, float d, float e)
     
    static int
    min(int a, int b)
     
    static int
    min(int a, int b, int c)
     
    static int
    min(int a, int b, int c, int d)
     
    static int
    min(int a, int b, int c, int d, int e)
     
    static int
    nextPowerOfTwo(int value)
     
    static float[]
    normalize(float[] weights)
     
    static <E> void
    normalize(E[] list, PZMath.FloatGet<E> floatGet, PZMath.FloatSet<E> floatSet)
     
    static ArrayList<Double>
    normalize(ArrayList<Double> list)
     
    static <E> void
    normalize(List<E> list, PZMath.FloatGet<E> floatGet, PZMath.FloatSet<E> floatSet)
     
    static float
    pow(float a, float b)
     
    static float
    radToDeg(float radians)
     
    static org.lwjgl.util.vector.Vector3f
    rotateVector(float vx, float vy, float vz, float qx, float qy, float qz, float qw, org.lwjgl.util.vector.Vector3f out_result)
     
    static Vector2
    rotateVector(float vx, float vy, float qx, float qy, float qz, float qw, Vector2 out_result)
     
    static org.lwjgl.util.vector.Vector3f
    rotateVector(org.lwjgl.util.vector.Vector3f in_vector, org.lwjgl.util.vector.Quaternion in_quaternion, org.lwjgl.util.vector.Vector3f out_result)
     
    static float
    roundFloat(float value, int scale)
     
    static float
    roundFloatPos(float number, int scale)
     
    static float
    roundFromEdges(float val)
     
    static int
    roundToInt(float val)
     
    static float
    roundToIntPlus05(float val)
     
    static float
    roundToNearest(float val)
     
    static org.lwjgl.util.vector.Quaternion
    setFromAxisAngle(float ax, float ay, float az, float angleRadians, org.lwjgl.util.vector.Quaternion out_result)
     
    static int
    sign(float val)
     
    static org.lwjgl.util.vector.Quaternion
    slerp(org.lwjgl.util.vector.Quaternion result, org.lwjgl.util.vector.Quaternion from, org.lwjgl.util.vector.Quaternion to, float alpha)
     
    static float
    sqrt(float val)
     
    static float
    step(float from, float to, float delta)
     
    static PZMath.SideOfLine
    testSideOfLine(float x1, float y1, float x2, float y2, float px, float py)
     
    static double
    tryParseDouble(String varStr, double defaultVal)
     
    static float
    tryParseFloat(String varStr, float defaultVal)
     
    static int
    tryParseInt(String varStr, int defaultVal)
     
    static float
    wrap(float val, float range)
     
    static float
    wrap(float in_val, float in_min, float in_max)
     

    Methods inherited from class Object

    equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

    • PI

      public static final float PI
      The double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.
      See Also:

    • PI2

      public static final float PI2
      See Also:

    • halfPI

      public static final float halfPI
      See Also:

    • degToRads

      public static final float degToRads
      Conversion ratios, Degrees to Radians and back
      See Also:

    • radToDegs

      public static final float radToDegs
      See Also:

    • microsToNanos

      public static final long microsToNanos
      See Also:

    • millisToMicros

      public static final long millisToMicros
      See Also:

    • secondsToMillis

      public static final long secondsToMillis
      See Also:

    • secondsToNanos

      public static long secondsToNanos

  • Constructor Details

    • PZMath

      public PZMath()

  • Method Details

    • almostUnitIdentity

      public static float almostUnitIdentity(float x)
      Almost Unit Identity This is a near-identiy function that maps the unit interval into itself. It is the cousin of smoothstep(), in that it maps 0 to 0, 1 to 1, and has a 0 derivative at the origin, just like smoothstep. However, instead of having a 0 derivative at 1, it has a derivative of 1 at that point. It's equivalent to the Almost Identiy above with n=0 and m=1. Since it's a cubic just like smoothstep() it is very fast to evaluate. https://iquilezles.org/www/articles/functions/functions.htm
      Parameters:
      x - value in [0..1]
      Returns:
      value in [0..1]

    • almostIdentity

      public static float almostIdentity(float x, float m, float n)
      Almost Identity Imagine you don't want to modify a signal unless it's drops to zero or close to it, in which case you want to replace the value with a small possitive constant. Then, rather than clamping the value and introduce a discontinuity, you can smoothly blend the signal into the desired clipped value. So, let m be the threshold (anything above m stays unchanged), and n the value things will take when the signal is zero. Then, the following function does the soft clipping (in a cubic fashion): https://iquilezles.org/www/articles/functions/functions.htm
      Parameters:
      x - value in [0..1]
      m -
      n -
      Returns:
      value in [0..1]

    • gain

      public static float gain(float x, float k)
      Gain Remapping the unit interval into the unit interval by expanding the sides and compressing the center, and keeping 1/2 mapped to 1/2, that can be done with the gain() function. This was a common function in RSL tutorials (the Renderman Shading Language). k=1 is the identity curve, kinvalid input: '<'1 produces the classic gain() shape, and k>1 produces "s" shaped curces. The curves are symmetric (and inverse) for k=a and k=1/a. https://iquilezles.org/www/articles/functions/functions.htm

    • clamp

      public static float clamp(float val, float min, float max)
      Result is clamped between min and max.
      Returns:
      min invalid input: '<'= val invalid input: '<'= max

    • clamp

      public static long clamp(long val, long min, long max)

    • clamp

      public static int clamp(int val, int min, int max)
      Result is clamped between min and max.
      Returns:
      min invalid input: '<'= val invalid input: '<'= max

    • clamp

      public static double clamp(double val, double min, double max)

    • clampFloat

      public static float clampFloat(float val, float min, float max)

    • clamp_01

      public static float clamp_01(float val)

    • clampDouble_01

      public static double clampDouble_01(double val)

    • setFromAxisAngle

      public static org.lwjgl.util.vector.Quaternion setFromAxisAngle(float ax, float ay, float az, float angleRadians, org.lwjgl.util.vector.Quaternion out_result)

    • lerp

      public static float lerp(float src, float dest, float alpha)

    • lerp

      public static float lerp(float src, float dest, float alpha, LerpType lerpType)

    • lerpAngle

      public static float lerpAngle(float src, float dest, float alpha)

    • lerp

      public static org.lwjgl.util.vector.Vector3f lerp(org.lwjgl.util.vector.Vector3f out, org.lwjgl.util.vector.Vector3f a, org.lwjgl.util.vector.Vector3f b, float t)

    • lerp

      public static Vector3 lerp(Vector3 out, Vector3 a, Vector3 b, float t)

    • lerp

      public static Vector2 lerp(Vector2 out, Vector2 a, Vector2 b, float t)

    • c_lerp

      public static float c_lerp(float src, float dest, float alpha)

    • slerp

      public static org.lwjgl.util.vector.Quaternion slerp(org.lwjgl.util.vector.Quaternion result, org.lwjgl.util.vector.Quaternion from, org.lwjgl.util.vector.Quaternion to, float alpha)

    • sqrt

      public static float sqrt(float val)

    • lerpFunc_EaseOutQuad

      public static float lerpFunc_EaseOutQuad(float x)

    • lerpFunc_EaseInQuad

      public static float lerpFunc_EaseInQuad(float x)

    • lerpFunc_EaseOutInQuad

      public static float lerpFunc_EaseOutInQuad(float x)

    • tryParseDouble

      public static double tryParseDouble(String varStr, double defaultVal)

    • tryParseFloat

      public static float tryParseFloat(String varStr, float defaultVal)

    • canParseFloat

      public static boolean canParseFloat(String varStr)

    • tryParseInt

      public static int tryParseInt(String varStr, int defaultVal)

    • pow

      public static float pow(float a, float b)

    • degToRad

      public static float degToRad(float degrees)

    • radToDeg

      public static float radToDeg(float radians)

    • getClosestAngle

      public static float getClosestAngle(float in_radsA, float in_radsB)

    • getClosestAngleDegrees

      public static float getClosestAngleDegrees(float in_degsA, float in_degsB)

    • sign

      public static int sign(float val)

    • fastfloor

      public static int fastfloor(double val)

    • fastfloor

      public static int fastfloor(float val)

    • coorddivision

      public static int coorddivision(int value, int divisor)

    • coordmodulo

      public static int coordmodulo(int value, int divisor)

    • coordmodulof

      public static float coordmodulof(float value, int divisor)

    • floor

      public static float floor(float val)

    • floor

      public static double floor(double val)

    • ceil

      public static float ceil(float val)

    • frac

      public static float frac(float val)

    • wrap

      public static float wrap(float val, float range)

    • wrap

      public static float wrap(float in_val, float in_min, float in_max)

    • max

      public static float max(float a, float b)

    • max

      public static float max(float a, float b, float c)

    • max

      public static float max(float a, float b, float c, float d)

    • max

      public static float max(float a, float b, float c, float d, float e)

    • max

      public static int max(int a, int b)

    • max

      public static int max(int a, int b, int c)

    • max

      public static int max(int a, int b, int c, int d)

    • max

      public static int max(int a, int b, int c, int d, int e)

    • min

      public static float min(float a, float b)

    • min

      public static float min(float a, float b, float c)

    • min

      public static float min(float a, float b, float c, float d)

    • min

      public static float min(float a, float b, float c, float d, float e)

    • min

      public static int min(int a, int b)

    • min

      public static int min(int a, int b, int c)

    • min

      public static int min(int a, int b, int c, int d)

    • min

      public static int min(int a, int b, int c, int d, int e)

    • abs

      public static float abs(float val)

    • equal

      public static boolean equal(float a, float b)

    • equal

      public static boolean equal(float a, float b, float delta)

    • convertMatrix

      public static org.lwjgl.util.vector.Matrix4f convertMatrix(org.joml.Matrix4f src, org.lwjgl.util.vector.Matrix4f dst)

    • convertMatrix

      public static org.joml.Matrix4f convertMatrix(org.lwjgl.util.vector.Matrix4f src, org.joml.Matrix4f dst)

    • step

      public static float step(float from, float to, float delta)

    • angleBetween

      public static float angleBetween(Vector2 va, Vector2 vb)

    • angleBetween

      public static float angleBetween(float in_ax, float in_ay, float in_bx, float in_by)

    • angleBetweenNormalized

      public static float angleBetweenNormalized(float ax, float bx, float ay, float by)

    • acosf

      public static float acosf(float a)

    • calculateBearing

      public static float calculateBearing(Vector3 in_fromPosition, Vector2 in_fromForward, Vector3 in_toPosition)

    • rotateVector

      public static org.lwjgl.util.vector.Vector3f rotateVector(org.lwjgl.util.vector.Vector3f in_vector, org.lwjgl.util.vector.Quaternion in_quaternion, org.lwjgl.util.vector.Vector3f out_result)

    • rotateVector

      public static org.lwjgl.util.vector.Vector3f rotateVector(float vx, float vy, float vz, float qx, float qy, float qz, float qw, org.lwjgl.util.vector.Vector3f out_result)

    • rotateVector

      public static Vector2 rotateVector(float vx, float vy, float qx, float qy, float qz, float qw, Vector2 out_result)

    • testSideOfLine

      public static PZMath.SideOfLine testSideOfLine(float x1, float y1, float x2, float y2, float px, float py)

    • normalize

      public static <E> void normalize(List<E> list, PZMath.FloatGet<E> floatGet, PZMath.FloatSet<E> floatSet)

    • normalize

      public static <E> void normalize(E[] list, PZMath.FloatGet<E> floatGet, PZMath.FloatSet<E> floatSet)

    • normalize

      public static float[] normalize(float[] weights)

    • normalize

      public static ArrayList<Double> normalize(ArrayList<Double> list)

    • roundFloatPos

      public static float roundFloatPos(float number, int scale)

    • roundFloat

      public static float roundFloat(float value, int scale)

    • nextPowerOfTwo

      public static int nextPowerOfTwo(int value)

    • roundToNearest

      public static float roundToNearest(float val)

    • roundToInt

      public static int roundToInt(float val)

    • roundToIntPlus05

      public static float roundToIntPlus05(float val)

    • roundFromEdges

      public static float roundFromEdges(float val)

    • closestVector3

      public static Vector3 closestVector3(float lx0, float ly0, float lz0, float lx1, float ly1, float lz1, float x, float y, float z)

    • isLeft

      public static float isLeft(float x0, float y0, float x1, float y1, float x2, float y2)

    • intersectLineSegments

      public static boolean intersectLineSegments(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, org.joml.Vector2f intersection)

    • closestPointOnLineSegment

      public static double closestPointOnLineSegment(float x1, float y1, float x2, float y2, float px, float py, double epsilon, org.joml.Vector2f out)

    • closestPointsOnLineSegments

      public static double closestPointsOnLineSegments(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, org.joml.Vector2f p1, org.joml.Vector2f p2)