From a3255e4f450aee7458b338ec8405dbeadeb47821 Mon Sep 17 00:00:00 2001 From: "Sha..rd" Date: Thu, 19 Jul 2012 23:52:35 +0000 Subject: [PATCH] * Javadoc fixes to FastMath git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@9570 75d07b2b-3a1a-0410-a2c5-0572b91ccdca --- engine/src/core/com/jme3/math/FastMath.java | 1986 ++++++++++--------- 1 file changed, 999 insertions(+), 987 deletions(-) diff --git a/engine/src/core/com/jme3/math/FastMath.java b/engine/src/core/com/jme3/math/FastMath.java index 983605af2..a230cd9a6 100644 --- a/engine/src/core/com/jme3/math/FastMath.java +++ b/engine/src/core/com/jme3/math/FastMath.java @@ -1,987 +1,999 @@ -/* - * Copyright (c) 2009-2010 jMonkeyEngine - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of 'jMonkeyEngine' nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package com.jme3.math; - -import java.util.Random; - -/** - * FastMath provides 'fast' math approximations and float equivalents of Math - * functions. These are all used as static values and functions. - * - * @author Various - * @version $Id: FastMath.java,v 1.45 2007/08/26 08:44:20 irrisor Exp $ - */ -final public class FastMath { - - private FastMath() { - } - /** A "close to zero" double epsilon value for use*/ - public static final double DBL_EPSILON = 2.220446049250313E-16d; - /** A "close to zero" float epsilon value for use*/ - public static final float FLT_EPSILON = 1.1920928955078125E-7f; - /** A "close to zero" float epsilon value for use*/ - public static final float ZERO_TOLERANCE = 0.0001f; - public static final float ONE_THIRD = 1f / 3f; - /** The value PI as a float. (180 degrees) */ - public static final float PI = (float) Math.PI; - /** The value 2PI as a float. (360 degrees) */ - public static final float TWO_PI = 2.0f * PI; - /** The value PI/2 as a float. (90 degrees) */ - public static final float HALF_PI = 0.5f * PI; - /** The value PI/4 as a float. (45 degrees) */ - public static final float QUARTER_PI = 0.25f * PI; - /** The value 1/PI as a float. */ - public static final float INV_PI = 1.0f / PI; - /** The value 1/(2PI) as a float. */ - public static final float INV_TWO_PI = 1.0f / TWO_PI; - /** A value to multiply a degree value by, to convert it to radians. */ - public static final float DEG_TO_RAD = PI / 180.0f; - /** A value to multiply a radian value by, to convert it to degrees. */ - public static final float RAD_TO_DEG = 180.0f / PI; - /** A precreated random object for random numbers. */ - public static final Random rand = new Random(System.currentTimeMillis()); - - /** - * Returns true if the number is a power of 2 (2,4,8,16...) - * - * A good implementation found on the Java boards. note: a number is a power - * of two if and only if it is the smallest number with that number of - * significant bits. Therefore, if you subtract 1, you know that the new - * number will have fewer bits, so ANDing the original number with anything - * less than it will give 0. - * - * @param number - * The number to test. - * @return True if it is a power of two. - */ - public static boolean isPowerOfTwo(int number) { - return (number > 0) && (number & (number - 1)) == 0; - } - - public static int nearestPowerOfTwo(int number) { - return (int) Math.pow(2, Math.ceil(Math.log(number) / Math.log(2))); - } - - /** - * Linear interpolation from startValue to endValue by the given percent. - * Basically: ((1 - percent) * startValue) + (percent * endValue) - * - * @param scale - * scale value to use. if 1, use endValue, if 0, use startValue. - * @param startValue - * Begining value. 0% of f - * @param endValue - * ending value. 100% of f - * @return The interpolated value between startValue and endValue. - */ - public static float interpolateLinear(float scale, float startValue, float endValue) { - if (startValue == endValue) { - return startValue; - } - if (scale <= 0f) { - return startValue; - } - if (scale >= 1f) { - return endValue; - } - return ((1f - scale) * startValue) + (scale * endValue); - } - - /** - * Linear interpolation from startValue to endValue by the given percent. - * Basically: ((1 - percent) * startValue) + (percent * endValue) - * - * @param scale - * scale value to use. if 1, use endValue, if 0, use startValue. - * @param startValue - * Begining value. 0% of f - * @param endValue - * ending value. 100% of f - * @param store a vector3f to store the result - * @return The interpolated value between startValue and endValue. - */ - public static Vector3f interpolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store) { - if (store == null) { - store = new Vector3f(); - } - store.x = interpolateLinear(scale, startValue.x, endValue.x); - store.y = interpolateLinear(scale, startValue.y, endValue.y); - store.z = interpolateLinear(scale, startValue.z, endValue.z); - return store; - } - - /** - * Linear interpolation from startValue to endValue by the given percent. - * Basically: ((1 - percent) * startValue) + (percent * endValue) - * - * @param scale - * scale value to use. if 1, use endValue, if 0, use startValue. - * @param startValue - * Begining value. 0% of f - * @param endValue - * ending value. 100% of f - * @return The interpolated value between startValue and endValue. - */ - public static Vector3f interpolateLinear(float scale, Vector3f startValue, Vector3f endValue) { - return interpolateLinear(scale, startValue, endValue, null); - } - - /** - * Linear extrapolation from startValue to endValue by the given scale. - * if scale is between 0 and 1 this method returns the same result as interpolateLinear - * if the scale is over 1 the value is linearly extrapolated. - * Note that the end value is the value for a scale of 1. - * @param scale the scale for extrapolation - * @param startValue the starting value (scale = 0) - * @param endValue the end value (scale = 1) - * @return an extrapolation for the given parameters - */ - public static float extrapolateLinear(float scale, float startValue, float endValue) { -// if (scale <= 0f) { -// return startValue; -// } - return ((1f - scale) * startValue) + (scale * endValue); - } - - /** - * Linear extrapolation from startValue to endValue by the given scale. - * if scale is between 0 and 1 this method returns the same result as interpolateLinear - * if the scale is over 1 the value is linearly extrapolated. - * Note that the end value is the value for a scale of 1. - * @param scale the scale for extrapolation - * @param startValue the starting value (scale = 0) - * @param endValue the end value (scale = 1) - * @param store an initialized vector to store the return value - * @return an extrapolation for the given parameters - */ - public static Vector3f extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store) { - if (store == null) { - store = new Vector3f(); - } -// if (scale <= 1f) { -// return interpolateLinear(scale, startValue, endValue, store); -// } - store.x = extrapolateLinear(scale, startValue.x, endValue.x); - store.y = extrapolateLinear(scale, startValue.y, endValue.y); - store.z = extrapolateLinear(scale, startValue.z, endValue.z); - return store; - } - - /** - * Linear extrapolation from startValue to endValue by the given scale. - * if scale is between 0 and 1 this method returns the same result as interpolateLinear - * if the scale is over 1 the value is linearly extrapolated. - * Note that the end value is the value for a scale of 1. - * @param scale the scale for extrapolation - * @param startValue the starting value (scale = 0) - * @param endValue the end value (scale = 1) - * @return an extrapolation for the given parameters - */ - public static Vector3f extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue) { - return extrapolateLinear(scale, startValue, endValue, null); - } - - /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. - * here is the interpolation matrix - * m = [ 0.0 1.0 0.0 0.0 ] - * [-T 0.0 T 0.0 ] - * [ 2T T-3 3-2T -T ] - * [-T 2-T T-2 T ] - * where T is the curve tension - * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 - * @param u value from 0 to 1 - * @param T The tension of the curve - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @return catmull-Rom interpolation - */ - public static float interpolateCatmullRom(float u, float T, float p0, float p1, float p2, float p3) { - float c1, c2, c3, c4; - c1 = p1; - c2 = -1.0f * T * p0 + T * p2; - c3 = 2 * T * p0 + (T - 3) * p1 + (3 - 2 * T) * p2 + -T * p3; - c4 = -T * p0 + (2 - T) * p1 + (T - 2) * p2 + T * p3; - - return (float) (((c4 * u + c3) * u + c2) * u + c1); - } - - /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. - * here is the interpolation matrix - * m = [ 0.0 1.0 0.0 0.0 ] - * [-T 0.0 T 0.0 ] - * [ 2T T-3 3-2T -T ] - * [-T 2-T T-2 T ] - * where T is the tension of the curve - * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 - * @param u value from 0 to 1 - * @param T The tension of the curve - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @param store a Vector3f to store the result - * @return catmull-Rom interpolation - */ - public static Vector3f interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store) { - if (store == null) { - store = new Vector3f(); - } - store.x = interpolateCatmullRom(u, T, p0.x, p1.x, p2.x, p3.x); - store.y = interpolateCatmullRom(u, T, p0.y, p1.y, p2.y, p3.y); - store.z = interpolateCatmullRom(u, T, p0.z, p1.z, p2.z, p3.z); - return store; - } - - /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. - * here is the interpolation matrix - * m = [ 0.0 1.0 0.0 0.0 ] - * [-T 0.0 T 0.0 ] - * [ 2T T-3 3-2T -T ] - * [-T 2-T T-2 T ] - * where T is the tension of the curve - * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 - * @param u value from 0 to 1 - * @param T The tension of the curve - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @return catmull-Rom interpolation - */ - public static Vector3f interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { - return interpolateCatmullRom(u, T, p0, p1, p2, p3, null); - } - - /**Interpolate a spline between at least 4 control points following the Bezier equation. - * here is the interpolation matrix - * m = [ -1.0 3.0 -3.0 1.0 ] - * [ 3.0 -6.0 3.0 0.0 ] - * [ -3.0 3.0 0.0 0.0 ] - * [ 1.0 0.0 0.0 0.0 ] - * where T is the curve tension - * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 - * @param u value from 0 to 1 - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @return Bezier interpolation - */ - public static float interpolateBezier(float u, float p0, float p1, float p2, float p3) { - float oneMinusU = 1.0f - u; - float oneMinusU2 = oneMinusU * oneMinusU; - float u2 = u * u; - return p0 * oneMinusU2 * oneMinusU - + 3.0f * p1 * u * oneMinusU2 - + 3.0f * p2 * u2 * oneMinusU - + p3 * u2 * u; - } - - /**Interpolate a spline between at least 4 control points following the Bezier equation. - * here is the interpolation matrix - * m = [ -1.0 3.0 -3.0 1.0 ] - * [ 3.0 -6.0 3.0 0.0 ] - * [ -3.0 3.0 0.0 0.0 ] - * [ 1.0 0.0 0.0 0.0 ] - * where T is the tension of the curve - * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 - * @param u value from 0 to 1 - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @param store a Vector3f to store the result - * @return Bezier interpolation - */ - public static Vector3f interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store) { - if (store == null) { - store = new Vector3f(); - } - store.x = interpolateBezier(u, p0.x, p1.x, p2.x, p3.x); - store.y = interpolateBezier(u, p0.y, p1.y, p2.y, p3.y); - store.z = interpolateBezier(u, p0.z, p1.z, p2.z, p3.z); - return store; - } - - /**Interpolate a spline between at least 4 control points following the Bezier equation. - * here is the interpolation matrix - * m = [ -1.0 3.0 -3.0 1.0 ] - * [ 3.0 -6.0 3.0 0.0 ] - * [ -3.0 3.0 0.0 0.0 ] - * [ 1.0 0.0 0.0 0.0 ] - * where T is the tension of the curve - * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 - * @param u value from 0 to 1 - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @return Bezier interpolation - */ - public static Vector3f interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { - return interpolateBezier(u, p0, p1, p2, p3, null); - } - - /** - * Compute the lenght on a catmull rom spline between control point 1 and 2 - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @param startRange the starting range on the segment (use 0) - * @param endRange the end range on the segment (use 1) - * @param curveTension the curve tension - * @return the length of the segment - */ - public static float getCatmullRomP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, float startRange, float endRange, float curveTension) { - - float epsilon = 0.001f; - float middleValue = (startRange + endRange) * 0.5f; - Vector3f start = p1.clone(); - if (startRange != 0) { - FastMath.interpolateCatmullRom(startRange, curveTension, p0, p1, p2, p3, start); - } - Vector3f end = p2.clone(); - if (endRange != 1) { - FastMath.interpolateCatmullRom(endRange, curveTension, p0, p1, p2, p3, end); - } - Vector3f middle = FastMath.interpolateCatmullRom(middleValue, curveTension, p0, p1, p2, p3); - float l = end.subtract(start).length(); - float l1 = middle.subtract(start).length(); - float l2 = end.subtract(middle).length(); - float len = l1 + l2; - if (l + epsilon < len) { - l1 = getCatmullRomP1toP2Length(p0, p1, p2, p3, startRange, middleValue, curveTension); - l2 = getCatmullRomP1toP2Length(p0, p1, p2, p3, middleValue, endRange, curveTension); - } - l = l1 + l2; - return l; - } - - /** - * Compute the lenght on a bezier spline between control point 1 and 2 - * @param p0 control point 0 - * @param p1 control point 1 - * @param p2 control point 2 - * @param p3 control point 3 - * @return the length of the segment - */ - public static float getBezierP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { - float delta = 0.02f, t = 0.0f, result = 0.0f; - Vector3f v1 = p0.clone(), v2 = new Vector3f(); - while (t <= 1.0f) { - FastMath.interpolateBezier(t, p0, p1, p2, p3, v2); - result += v1.subtractLocal(v2).length(); - v1.set(v2); - t += delta; - } - return result; - } - - /** - * Returns the arc cosine of an angle given in radians.
- * Special cases: - * - * @param fValue The angle, in radians. - * @return fValue's acos - * @see java.lang.Math#acos(double) - */ - public static float acos(float fValue) { - if (-1.0f < fValue) { - if (fValue < 1.0f) { - return (float) Math.acos(fValue); - } - - return 0.0f; - } - - return PI; - } - - /** - * Returns the arc sine of an angle given in radians.
- * Special cases: - * - * @param fValue The angle, in radians. - * @return fValue's asin - * @see java.lang.Math#asin(double) - */ - public static float asin(float fValue) { - if (-1.0f < fValue) { - if (fValue < 1.0f) { - return (float) Math.asin(fValue); - } - - return HALF_PI; - } - - return -HALF_PI; - } - - /** - * Returns the arc tangent of an angle given in radians.
- * @param fValue The angle, in radians. - * @return fValue's atan - * @see java.lang.Math#atan(double) - */ - public static float atan(float fValue) { - return (float) Math.atan(fValue); - } - - /** - * A direct call to Math.atan2. - * @param fY - * @param fX - * @return Math.atan2(fY,fX) - * @see java.lang.Math#atan2(double, double) - */ - public static float atan2(float fY, float fX) { - return (float) Math.atan2(fY, fX); - } - - /** - * Rounds a fValue up. A call to Math.ceil - * @param fValue The value. - * @return The fValue rounded up - * @see java.lang.Math#ceil(double) - */ - public static float ceil(float fValue) { - return (float) Math.ceil(fValue); - } - - /** - * Fast Trig functions for x86. This forces the trig functiosn to stay - * within the safe area on the x86 processor (-45 degrees to +45 degrees) - * The results may be very slightly off from what the Math and StrictMath - * trig functions give due to rounding in the angle reduction but it will be - * very very close. - * - * note: code from wiki posting on java.net by jeffpk - */ - public static float reduceSinAngle(float radians) { - radians %= TWO_PI; // put us in -2PI to +2PI space - if (Math.abs(radians) > PI) { // put us in -PI to +PI space - radians = radians - (TWO_PI); - } - if (Math.abs(radians) > HALF_PI) {// put us in -PI/2 to +PI/2 space - radians = PI - radians; - } - - return radians; - } - - /** - * Returns sine of a value. - * - * note: code from wiki posting on java.net by jeffpk - * - * @param fValue - * The value to sine, in radians. - * @return The sine of fValue. - * @see java.lang.Math#sin(double) - */ - public static float sin2(float fValue) { - fValue = reduceSinAngle(fValue); // limits angle to between -PI/2 and +PI/2 - if (Math.abs(fValue) <= Math.PI / 4) { - return (float) Math.sin(fValue); - } - - return (float) Math.cos(Math.PI / 2 - fValue); - } - - /** - * Returns cos of a value. - * - * @param fValue - * The value to cosine, in radians. - * @return The cosine of fValue. - * @see java.lang.Math#cos(double) - */ - public static float cos2(float fValue) { - return sin2(fValue + HALF_PI); - } - - public static float cos(float v) { - return (float) Math.cos(v); - } - - public static float sin(float v) { - return (float) Math.sin(v); - } - - /** - * Returns E^fValue - * @param fValue Value to raise to a power. - * @return The value E^fValue - * @see java.lang.Math#exp(double) - */ - public static float exp(float fValue) { - return (float) Math.exp(fValue); - } - - /** - * Returns Absolute value of a float. - * @param fValue The value to abs. - * @return The abs of the value. - * @see java.lang.Math#abs(float) - */ - public static float abs(float fValue) { - if (fValue < 0) { - return -fValue; - } - return fValue; - } - - /** - * Returns a number rounded down. - * @param fValue The value to round - * @return The given number rounded down - * @see java.lang.Math#floor(double) - */ - public static float floor(float fValue) { - return (float) Math.floor(fValue); - } - - /** - * Returns 1/sqrt(fValue) - * @param fValue The value to process. - * @return 1/sqrt(fValue) - * @see java.lang.Math#sqrt(double) - */ - public static float invSqrt(float fValue) { - return (float) (1.0f / Math.sqrt(fValue)); - } - - public static float fastInvSqrt(float x) { - float xhalf = 0.5f * x; - int i = Float.floatToIntBits(x); // get bits for floating value - i = 0x5f375a86 - (i >> 1); // gives initial guess y0 - x = Float.intBitsToFloat(i); // convert bits back to float - x = x * (1.5f - xhalf * x * x); // Newton step, repeating increases accuracy - return x; - } - - /** - * Returns the log base E of a value. - * @param fValue The value to log. - * @return The log of fValue base E - * @see java.lang.Math#log(double) - */ - public static float log(float fValue) { - return (float) Math.log(fValue); - } - - /** - * Returns the logarithm of value with given base, calculated as log(value)/log(base), - * so that pow(base, return)==value (contributed by vear) - * @param value The value to log. - * @param base Base of logarithm. - * @return The logarithm of value with given base - */ - public static float log(float value, float base) { - return (float) (Math.log(value) / Math.log(base)); - } - - /** - * Returns a number raised to an exponent power. fBase^fExponent - * @param fBase The base value (IE 2) - * @param fExponent The exponent value (IE 3) - * @return base raised to exponent (IE 8) - * @see java.lang.Math#pow(double, double) - */ - public static float pow(float fBase, float fExponent) { - return (float) Math.pow(fBase, fExponent); - } - - /** - * Returns the value squared. fValue ^ 2 - * @param fValue The vaule to square. - * @return The square of the given value. - */ - public static float sqr(float fValue) { - return fValue * fValue; - } - - /** - * Returns the square root of a given value. - * @param fValue The value to sqrt. - * @return The square root of the given value. - * @see java.lang.Math#sqrt(double) - */ - public static float sqrt(float fValue) { - return (float) Math.sqrt(fValue); - } - - /** - * Returns the tangent of a value. If USE_FAST_TRIG is enabled, an approximate value - * is returned. Otherwise, a direct value is used. - * @param fValue The value to tangent, in radians. - * @return The tangent of fValue. - * @see java.lang.Math#tan(double) - */ - public static float tan(float fValue) { - return (float) Math.tan(fValue); - } - - /** - * Returns 1 if the number is positive, -1 if the number is negative, and 0 otherwise - * @param iValue The integer to examine. - * @return The integer's sign. - */ - public static int sign(int iValue) { - if (iValue > 0) { - return 1; - } - if (iValue < 0) { - return -1; - } - return 0; - } - - /** - * Returns 1 if the number is positive, -1 if the number is negative, and 0 otherwise - * @param fValue The float to examine. - * @return The float's sign. - */ - public static float sign(float fValue) { - return Math.signum(fValue); - } - - /** - * Given 3 points in a 2d plane, this function computes if the points going from A-B-C - * are moving counter clock wise. - * @param p0 Point 0. - * @param p1 Point 1. - * @param p2 Point 2. - * @return 1 If they are CCW, -1 if they are not CCW, 0 if p2 is between p0 and p1. - */ - public static int counterClockwise(Vector2f p0, Vector2f p1, Vector2f p2) { - float dx1, dx2, dy1, dy2; - dx1 = p1.x - p0.x; - dy1 = p1.y - p0.y; - dx2 = p2.x - p0.x; - dy2 = p2.y - p0.y; - if (dx1 * dy2 > dy1 * dx2) { - return 1; - } - if (dx1 * dy2 < dy1 * dx2) { - return -1; - } - if ((dx1 * dx2 < 0) || (dy1 * dy2 < 0)) { - return -1; - } - if ((dx1 * dx1 + dy1 * dy1) < (dx2 * dx2 + dy2 * dy2)) { - return 1; - } - return 0; - } - - /** - * Test if a point is inside a triangle. 1 if the point is on the ccw side, - * -1 if the point is on the cw side, and 0 if it is on neither. - * @param t0 First point of the triangle. - * @param t1 Second point of the triangle. - * @param t2 Third point of the triangle. - * @param p The point to test. - * @return Value 1 or -1 if inside triangle, 0 otherwise. - */ - public static int pointInsideTriangle(Vector2f t0, Vector2f t1, Vector2f t2, Vector2f p) { - int val1 = counterClockwise(t0, t1, p); - if (val1 == 0) { - return 1; - } - int val2 = counterClockwise(t1, t2, p); - if (val2 == 0) { - return 1; - } - if (val2 != val1) { - return 0; - } - int val3 = counterClockwise(t2, t0, p); - if (val3 == 0) { - return 1; - } - if (val3 != val1) { - return 0; - } - return val3; - } - - /** - * A method that computes normal for a triangle defined by three vertices. - * @param v1 first vertex - * @param v2 second vertex - * @param v3 third vertex - * @return a normal for the face - */ - public static Vector3f computeNormal(Vector3f v1, Vector3f v2, Vector3f v3) { - Vector3f a1 = v1.subtract(v2); - Vector3f a2 = v3.subtract(v2); - return a2.crossLocal(a1).normalizeLocal(); - } - - /** - * Returns the determinant of a 4x4 matrix. - */ - public static float determinant(double m00, double m01, double m02, - double m03, double m10, double m11, double m12, double m13, - double m20, double m21, double m22, double m23, double m30, - double m31, double m32, double m33) { - - double det01 = m20 * m31 - m21 * m30; - double det02 = m20 * m32 - m22 * m30; - double det03 = m20 * m33 - m23 * m30; - double det12 = m21 * m32 - m22 * m31; - double det13 = m21 * m33 - m23 * m31; - double det23 = m22 * m33 - m23 * m32; - return (float) (m00 * (m11 * det23 - m12 * det13 + m13 * det12) - m01 - * (m10 * det23 - m12 * det03 + m13 * det02) + m02 - * (m10 * det13 - m11 * det03 + m13 * det01) - m03 - * (m10 * det12 - m11 * det02 + m12 * det01)); - } - - /** - * Returns a random float between 0 and 1. - * - * @return A random float between 0.0f (inclusive) to - * 1.0f (exclusive). - */ - public static float nextRandomFloat() { - return rand.nextFloat(); - } - - /** - * Returns a random integer between min and max. - * - * @return A random int between min (inclusive) to - * max (inclusive). - */ - public static int nextRandomInt(int min, int max) { - return (int) (nextRandomFloat() * (max - min + 1)) + min; - } - - public static int nextRandomInt() { - return rand.nextInt(); - } - - /** - * Converts a point from Spherical coordinates to Cartesian (using positive - * Y as up) and stores the results in the store var. - */ - public static Vector3f sphericalToCartesian(Vector3f sphereCoords, - Vector3f store) { - store.y = sphereCoords.x * FastMath.sin(sphereCoords.z); - float a = sphereCoords.x * FastMath.cos(sphereCoords.z); - store.x = a * FastMath.cos(sphereCoords.y); - store.z = a * FastMath.sin(sphereCoords.y); - - return store; - } - - /** - * Converts a point from Cartesian coordinates (using positive Y as up) to - * Spherical and stores the results in the store var. (Radius, Azimuth, - * Polar) - */ - public static Vector3f cartesianToSpherical(Vector3f cartCoords, - Vector3f store) { - float x = cartCoords.x; - if (x == 0) { - x = FastMath.FLT_EPSILON; - } - store.x = FastMath.sqrt((x * x) - + (cartCoords.y * cartCoords.y) - + (cartCoords.z * cartCoords.z)); - store.y = FastMath.atan(cartCoords.z / x); - if (x < 0) { - store.y += FastMath.PI; - } - store.z = FastMath.asin(cartCoords.y / store.x); - return store; - } - - /** - * Converts a point from Spherical coordinates to Cartesian (using positive - * Z as up) and stores the results in the store var. - */ - public static Vector3f sphericalToCartesianZ(Vector3f sphereCoords, - Vector3f store) { - store.z = sphereCoords.x * FastMath.sin(sphereCoords.z); - float a = sphereCoords.x * FastMath.cos(sphereCoords.z); - store.x = a * FastMath.cos(sphereCoords.y); - store.y = a * FastMath.sin(sphereCoords.y); - - return store; - } - - /** - * Converts a point from Cartesian coordinates (using positive Z as up) to - * Spherical and stores the results in the store var. (Radius, Azimuth, - * Polar) - */ - public static Vector3f cartesianZToSpherical(Vector3f cartCoords, - Vector3f store) { - float x = cartCoords.x; - if (x == 0) { - x = FastMath.FLT_EPSILON; - } - store.x = FastMath.sqrt((x * x) - + (cartCoords.y * cartCoords.y) - + (cartCoords.z * cartCoords.z)); - store.z = FastMath.atan(cartCoords.z / x); - if (x < 0) { - store.z += FastMath.PI; - } - store.y = FastMath.asin(cartCoords.y / store.x); - return store; - } - - /** - * Takes an value and expresses it in terms of min to max. - * - * @param val - - * the angle to normalize (in radians) - * @return the normalized angle (also in radians) - */ - public static float normalize(float val, float min, float max) { - if (Float.isInfinite(val) || Float.isNaN(val)) { - return 0f; - } - float range = max - min; - while (val > max) { - val -= range; - } - while (val < min) { - val += range; - } - return val; - } - - /** - * @param x - * the value whose sign is to be adjusted. - * @param y - * the value whose sign is to be used. - * @return x with its sign changed to match the sign of y. - */ - public static float copysign(float x, float y) { - if (y >= 0 && x <= -0) { - return -x; - } else if (y < 0 && x >= 0) { - return -x; - } else { - return x; - } - } - - /** - * Take a float input and clamp it between min and max. - * - * @param input - * @param min - * @param max - * @return clamped input - */ - public static float clamp(float input, float min, float max) { - return (input < min) ? min : (input > max) ? max : input; - } - - /** - * Clamps the given float to be between 0 and 1. - * - * @param input - * @return input clamped between 0 and 1. - */ - public static float saturate(float input) { - return clamp(input, 0f, 1f); - } - - /** - * Converts a single precision (32 bit) floating point value - * into half precision (16 bit). - * - *

Source: - * http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
broken link - * - * @param half The half floating point value as a short. - * @return floating point value of the half. - */ - public static float convertHalfToFloat(short half) { - switch ((int) half) { - case 0x0000: - return 0f; - case 0x8000: - return -0f; - case 0x7c00: - return Float.POSITIVE_INFINITY; - case 0xfc00: - return Float.NEGATIVE_INFINITY; - // TODO: Support for NaN? - default: - return Float.intBitsToFloat(((half & 0x8000) << 16) - | (((half & 0x7c00) + 0x1C000) << 13) - | ((half & 0x03FF) << 13)); - } - } - - public static short convertFloatToHalf(float flt) { - if (Float.isNaN(flt)) { - throw new UnsupportedOperationException("NaN to half conversion not supported!"); - } else if (flt == Float.POSITIVE_INFINITY) { - return (short) 0x7c00; - } else if (flt == Float.NEGATIVE_INFINITY) { - return (short) 0xfc00; - } else if (flt == 0f) { - return (short) 0x0000; - } else if (flt == -0f) { - return (short) 0x8000; - } else if (flt > 65504f) { - // max value supported by half float - return 0x7bff; - } else if (flt < -65504f) { - return (short) (0x7bff | 0x8000); - } else if (flt > 0f && flt < 5.96046E-8f) { - return 0x0001; - } else if (flt < 0f && flt > -5.96046E-8f) { - return (short) 0x8001; - } - - int f = Float.floatToIntBits(flt); - return (short) (((f >> 16) & 0x8000) - | ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) - | ((f >> 13) & 0x03ff)); - } -} +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.math; + +import java.util.Random; + +/** + * FastMath provides 'fast' math approximations and float equivalents of Math + * functions. These are all used as static values and functions. + * + * @author Various + * @version $Id: FastMath.java,v 1.45 2007/08/26 08:44:20 irrisor Exp $ + */ +final public class FastMath { + + private FastMath() { + } + /** A "close to zero" double epsilon value for use*/ + public static final double DBL_EPSILON = 2.220446049250313E-16d; + /** A "close to zero" float epsilon value for use*/ + public static final float FLT_EPSILON = 1.1920928955078125E-7f; + /** A "close to zero" float epsilon value for use*/ + public static final float ZERO_TOLERANCE = 0.0001f; + public static final float ONE_THIRD = 1f / 3f; + /** The value PI as a float. (180 degrees) */ + public static final float PI = (float) Math.PI; + /** The value 2PI as a float. (360 degrees) */ + public static final float TWO_PI = 2.0f * PI; + /** The value PI/2 as a float. (90 degrees) */ + public static final float HALF_PI = 0.5f * PI; + /** The value PI/4 as a float. (45 degrees) */ + public static final float QUARTER_PI = 0.25f * PI; + /** The value 1/PI as a float. */ + public static final float INV_PI = 1.0f / PI; + /** The value 1/(2PI) as a float. */ + public static final float INV_TWO_PI = 1.0f / TWO_PI; + /** A value to multiply a degree value by, to convert it to radians. */ + public static final float DEG_TO_RAD = PI / 180.0f; + /** A value to multiply a radian value by, to convert it to degrees. */ + public static final float RAD_TO_DEG = 180.0f / PI; + /** A precreated random object for random numbers. */ + public static final Random rand = new Random(System.currentTimeMillis()); + + /** + * Returns true if the number is a power of 2 (2,4,8,16...) + * + * A good implementation found on the Java boards. note: a number is a power + * of two if and only if it is the smallest number with that number of + * significant bits. Therefore, if you subtract 1, you know that the new + * number will have fewer bits, so ANDing the original number with anything + * less than it will give 0. + * + * @param number + * The number to test. + * @return True if it is a power of two. + */ + public static boolean isPowerOfTwo(int number) { + return (number > 0) && (number & (number - 1)) == 0; + } + + public static int nearestPowerOfTwo(int number) { + return (int) Math.pow(2, Math.ceil(Math.log(number) / Math.log(2))); + } + + /** + * Linear interpolation from startValue to endValue by the given percent. + * Basically: ((1 - percent) * startValue) + (percent * endValue) + * + * @param scale + * scale value to use. if 1, use endValue, if 0, use startValue. + * @param startValue + * Begining value. 0% of f + * @param endValue + * ending value. 100% of f + * @return The interpolated value between startValue and endValue. + */ + public static float interpolateLinear(float scale, float startValue, float endValue) { + if (startValue == endValue) { + return startValue; + } + if (scale <= 0f) { + return startValue; + } + if (scale >= 1f) { + return endValue; + } + return ((1f - scale) * startValue) + (scale * endValue); + } + + /** + * Linear interpolation from startValue to endValue by the given percent. + * Basically: ((1 - percent) * startValue) + (percent * endValue) + * + * @param scale + * scale value to use. if 1, use endValue, if 0, use startValue. + * @param startValue + * Begining value. 0% of f + * @param endValue + * ending value. 100% of f + * @param store a vector3f to store the result + * @return The interpolated value between startValue and endValue. + */ + public static Vector3f interpolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store) { + if (store == null) { + store = new Vector3f(); + } + store.x = interpolateLinear(scale, startValue.x, endValue.x); + store.y = interpolateLinear(scale, startValue.y, endValue.y); + store.z = interpolateLinear(scale, startValue.z, endValue.z); + return store; + } + + /** + * Linear interpolation from startValue to endValue by the given percent. + * Basically: ((1 - percent) * startValue) + (percent * endValue) + * + * @param scale + * scale value to use. if 1, use endValue, if 0, use startValue. + * @param startValue + * Begining value. 0% of f + * @param endValue + * ending value. 100% of f + * @return The interpolated value between startValue and endValue. + */ + public static Vector3f interpolateLinear(float scale, Vector3f startValue, Vector3f endValue) { + return interpolateLinear(scale, startValue, endValue, null); + } + + /** + * Linear extrapolation from startValue to endValue by the given scale. + * if scale is between 0 and 1 this method returns the same result as interpolateLinear + * if the scale is over 1 the value is linearly extrapolated. + * Note that the end value is the value for a scale of 1. + * @param scale the scale for extrapolation + * @param startValue the starting value (scale = 0) + * @param endValue the end value (scale = 1) + * @return an extrapolation for the given parameters + */ + public static float extrapolateLinear(float scale, float startValue, float endValue) { +// if (scale <= 0f) { +// return startValue; +// } + return ((1f - scale) * startValue) + (scale * endValue); + } + + /** + * Linear extrapolation from startValue to endValue by the given scale. + * if scale is between 0 and 1 this method returns the same result as interpolateLinear + * if the scale is over 1 the value is linearly extrapolated. + * Note that the end value is the value for a scale of 1. + * @param scale the scale for extrapolation + * @param startValue the starting value (scale = 0) + * @param endValue the end value (scale = 1) + * @param store an initialized vector to store the return value + * @return an extrapolation for the given parameters + */ + public static Vector3f extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store) { + if (store == null) { + store = new Vector3f(); + } +// if (scale <= 1f) { +// return interpolateLinear(scale, startValue, endValue, store); +// } + store.x = extrapolateLinear(scale, startValue.x, endValue.x); + store.y = extrapolateLinear(scale, startValue.y, endValue.y); + store.z = extrapolateLinear(scale, startValue.z, endValue.z); + return store; + } + + /** + * Linear extrapolation from startValue to endValue by the given scale. + * if scale is between 0 and 1 this method returns the same result as interpolateLinear + * if the scale is over 1 the value is linearly extrapolated. + * Note that the end value is the value for a scale of 1. + * @param scale the scale for extrapolation + * @param startValue the starting value (scale = 0) + * @param endValue the end value (scale = 1) + * @return an extrapolation for the given parameters + */ + public static Vector3f extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue) { + return extrapolateLinear(scale, startValue, endValue, null); + } + + /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. + * here is the interpolation matrix + * m = [ 0.0 1.0 0.0 0.0 ] + * [-T 0.0 T 0.0 ] + * [ 2T T-3 3-2T -T ] + * [-T 2-T T-2 T ] + * where T is the curve tension + * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 + * @param u value from 0 to 1 + * @param T The tension of the curve + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @return catmull-Rom interpolation + */ + public static float interpolateCatmullRom(float u, float T, float p0, float p1, float p2, float p3) { + float c1, c2, c3, c4; + c1 = p1; + c2 = -1.0f * T * p0 + T * p2; + c3 = 2 * T * p0 + (T - 3) * p1 + (3 - 2 * T) * p2 + -T * p3; + c4 = -T * p0 + (2 - T) * p1 + (T - 2) * p2 + T * p3; + + return (float) (((c4 * u + c3) * u + c2) * u + c1); + } + + /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. + * here is the interpolation matrix + * m = [ 0.0 1.0 0.0 0.0 ] + * [-T 0.0 T 0.0 ] + * [ 2T T-3 3-2T -T ] + * [-T 2-T T-2 T ] + * where T is the tension of the curve + * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 + * @param u value from 0 to 1 + * @param T The tension of the curve + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @param store a Vector3f to store the result + * @return catmull-Rom interpolation + */ + public static Vector3f interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store) { + if (store == null) { + store = new Vector3f(); + } + store.x = interpolateCatmullRom(u, T, p0.x, p1.x, p2.x, p3.x); + store.y = interpolateCatmullRom(u, T, p0.y, p1.y, p2.y, p3.y); + store.z = interpolateCatmullRom(u, T, p0.z, p1.z, p2.z, p3.z); + return store; + } + + /**Interpolate a spline between at least 4 control points following the Catmull-Rom equation. + * here is the interpolation matrix + * m = [ 0.0 1.0 0.0 0.0 ] + * [-T 0.0 T 0.0 ] + * [ 2T T-3 3-2T -T ] + * [-T 2-T T-2 T ] + * where T is the tension of the curve + * the result is a value between p1 and p2, t=0 for p1, t=1 for p2 + * @param u value from 0 to 1 + * @param T The tension of the curve + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @return catmull-Rom interpolation + */ + public static Vector3f interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { + return interpolateCatmullRom(u, T, p0, p1, p2, p3, null); + } + + /**Interpolate a spline between at least 4 control points following the Bezier equation. + * here is the interpolation matrix + * m = [ -1.0 3.0 -3.0 1.0 ] + * [ 3.0 -6.0 3.0 0.0 ] + * [ -3.0 3.0 0.0 0.0 ] + * [ 1.0 0.0 0.0 0.0 ] + * where T is the curve tension + * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 + * @param u value from 0 to 1 + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @return Bezier interpolation + */ + public static float interpolateBezier(float u, float p0, float p1, float p2, float p3) { + float oneMinusU = 1.0f - u; + float oneMinusU2 = oneMinusU * oneMinusU; + float u2 = u * u; + return p0 * oneMinusU2 * oneMinusU + + 3.0f * p1 * u * oneMinusU2 + + 3.0f * p2 * u2 * oneMinusU + + p3 * u2 * u; + } + + /**Interpolate a spline between at least 4 control points following the Bezier equation. + * here is the interpolation matrix + * m = [ -1.0 3.0 -3.0 1.0 ] + * [ 3.0 -6.0 3.0 0.0 ] + * [ -3.0 3.0 0.0 0.0 ] + * [ 1.0 0.0 0.0 0.0 ] + * where T is the tension of the curve + * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 + * @param u value from 0 to 1 + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @param store a Vector3f to store the result + * @return Bezier interpolation + */ + public static Vector3f interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store) { + if (store == null) { + store = new Vector3f(); + } + store.x = interpolateBezier(u, p0.x, p1.x, p2.x, p3.x); + store.y = interpolateBezier(u, p0.y, p1.y, p2.y, p3.y); + store.z = interpolateBezier(u, p0.z, p1.z, p2.z, p3.z); + return store; + } + + /**Interpolate a spline between at least 4 control points following the Bezier equation. + * here is the interpolation matrix + * m = [ -1.0 3.0 -3.0 1.0 ] + * [ 3.0 -6.0 3.0 0.0 ] + * [ -3.0 3.0 0.0 0.0 ] + * [ 1.0 0.0 0.0 0.0 ] + * where T is the tension of the curve + * the result is a value between p1 and p3, t=0 for p1, t=1 for p3 + * @param u value from 0 to 1 + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @return Bezier interpolation + */ + public static Vector3f interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { + return interpolateBezier(u, p0, p1, p2, p3, null); + } + + /** + * Compute the lenght on a catmull rom spline between control point 1 and 2 + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @param startRange the starting range on the segment (use 0) + * @param endRange the end range on the segment (use 1) + * @param curveTension the curve tension + * @return the length of the segment + */ + public static float getCatmullRomP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, float startRange, float endRange, float curveTension) { + + float epsilon = 0.001f; + float middleValue = (startRange + endRange) * 0.5f; + Vector3f start = p1.clone(); + if (startRange != 0) { + FastMath.interpolateCatmullRom(startRange, curveTension, p0, p1, p2, p3, start); + } + Vector3f end = p2.clone(); + if (endRange != 1) { + FastMath.interpolateCatmullRom(endRange, curveTension, p0, p1, p2, p3, end); + } + Vector3f middle = FastMath.interpolateCatmullRom(middleValue, curveTension, p0, p1, p2, p3); + float l = end.subtract(start).length(); + float l1 = middle.subtract(start).length(); + float l2 = end.subtract(middle).length(); + float len = l1 + l2; + if (l + epsilon < len) { + l1 = getCatmullRomP1toP2Length(p0, p1, p2, p3, startRange, middleValue, curveTension); + l2 = getCatmullRomP1toP2Length(p0, p1, p2, p3, middleValue, endRange, curveTension); + } + l = l1 + l2; + return l; + } + + /** + * Compute the lenght on a bezier spline between control point 1 and 2 + * @param p0 control point 0 + * @param p1 control point 1 + * @param p2 control point 2 + * @param p3 control point 3 + * @return the length of the segment + */ + public static float getBezierP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3) { + float delta = 0.02f, t = 0.0f, result = 0.0f; + Vector3f v1 = p0.clone(), v2 = new Vector3f(); + while (t <= 1.0f) { + FastMath.interpolateBezier(t, p0, p1, p2, p3, v2); + result += v1.subtractLocal(v2).length(); + v1.set(v2); + t += delta; + } + return result; + } + + /** + * Returns the arc cosine of a value.
+ * Special cases: + *

+ * @param fValue The value to arc cosine. + * @return The angle, in radians. + * @see java.lang.Math#acos(double) + */ + public static float acos(float fValue) { + if (-1.0f < fValue) { + if (fValue < 1.0f) { + return (float) Math.acos(fValue); + } + + return 0.0f; + } + + return PI; + } + + /** + * Returns the arc sine of a value.
+ * Special cases: + * + * @param fValue The value to arc sine. + * @return the angle in radians. + * @see java.lang.Math#asin(double) + */ + public static float asin(float fValue) { + if (-1.0f < fValue) { + if (fValue < 1.0f) { + return (float) Math.asin(fValue); + } + + return HALF_PI; + } + + return -HALF_PI; + } + + /** + * Returns the arc tangent of an angle given in radians.
+ * @param fValue The angle, in radians. + * @return fValue's atan + * @see java.lang.Math#atan(double) + */ + public static float atan(float fValue) { + return (float) Math.atan(fValue); + } + + /** + * A direct call to Math.atan2. + * @param fY + * @param fX + * @return Math.atan2(fY,fX) + * @see java.lang.Math#atan2(double, double) + */ + public static float atan2(float fY, float fX) { + return (float) Math.atan2(fY, fX); + } + + /** + * Rounds a fValue up. A call to Math.ceil + * @param fValue The value. + * @return The fValue rounded up + * @see java.lang.Math#ceil(double) + */ + public static float ceil(float fValue) { + return (float) Math.ceil(fValue); + } + + /** + * Fast Trig functions for x86. This forces the trig functiosn to stay + * within the safe area on the x86 processor (-45 degrees to +45 degrees) + * The results may be very slightly off from what the Math and StrictMath + * trig functions give due to rounding in the angle reduction but it will be + * very very close. + * + * note: code from wiki posting on java.net by jeffpk + */ + public static float reduceSinAngle(float radians) { + radians %= TWO_PI; // put us in -2PI to +2PI space + if (Math.abs(radians) > PI) { // put us in -PI to +PI space + radians = radians - (TWO_PI); + } + if (Math.abs(radians) > HALF_PI) {// put us in -PI/2 to +PI/2 space + radians = PI - radians; + } + + return radians; + } + + /** + * Returns sine of an angle. + * + * note: code from wiki posting on java.net by jeffpk + * + * @param fValue + * The angle to sine, in radians. + * @return The sine of fValue. + * @see java.lang.Math#sin(double) + */ + public static float sin2(float fValue) { + fValue = reduceSinAngle(fValue); // limits angle to between -PI/2 and +PI/2 + if (Math.abs(fValue) <= Math.PI / 4) { + return (float) Math.sin(fValue); + } + + return (float) Math.cos(Math.PI / 2 - fValue); + } + + /** + * Returns cos of an angle. + * + * @param fValue + * The angle to cosine, in radians. + * @return The cosine of fValue. + * @see java.lang.Math#cos(double) + */ + public static float cos2(float fValue) { + return sin2(fValue + HALF_PI); + } + + /** + * Returns cosine of an angle. Direct call to java.lang.Math + * @see Math#cos(double) + * @param v The angle to cosine. + * @return the cosine of the angle. + */ + public static float cos(float v) { + return (float) Math.cos(v); + } + + /** + * Returns the sine of an angle. Direct call to java.lang.Math + * @see Math#sin(double) + * @param v The angle to sine. + * @return the sine of the angle. + */ + public static float sin(float v) { + return (float) Math.sin(v); + } + + /** + * Returns E^fValue + * @param fValue Value to raise to a power. + * @return The value E^fValue + * @see java.lang.Math#exp(double) + */ + public static float exp(float fValue) { + return (float) Math.exp(fValue); + } + + /** + * Returns Absolute value of a float. + * @param fValue The value to abs. + * @return The abs of the value. + * @see java.lang.Math#abs(float) + */ + public static float abs(float fValue) { + if (fValue < 0) { + return -fValue; + } + return fValue; + } + + /** + * Returns a number rounded down. + * @param fValue The value to round + * @return The given number rounded down + * @see java.lang.Math#floor(double) + */ + public static float floor(float fValue) { + return (float) Math.floor(fValue); + } + + /** + * Returns 1/sqrt(fValue) + * @param fValue The value to process. + * @return 1/sqrt(fValue) + * @see java.lang.Math#sqrt(double) + */ + public static float invSqrt(float fValue) { + return (float) (1.0f / Math.sqrt(fValue)); + } + + public static float fastInvSqrt(float x) { + float xhalf = 0.5f * x; + int i = Float.floatToIntBits(x); // get bits for floating value + i = 0x5f375a86 - (i >> 1); // gives initial guess y0 + x = Float.intBitsToFloat(i); // convert bits back to float + x = x * (1.5f - xhalf * x * x); // Newton step, repeating increases accuracy + return x; + } + + /** + * Returns the log base E of a value. + * @param fValue The value to log. + * @return The log of fValue base E + * @see java.lang.Math#log(double) + */ + public static float log(float fValue) { + return (float) Math.log(fValue); + } + + /** + * Returns the logarithm of value with given base, calculated as log(value)/log(base), + * so that pow(base, return)==value (contributed by vear) + * @param value The value to log. + * @param base Base of logarithm. + * @return The logarithm of value with given base + */ + public static float log(float value, float base) { + return (float) (Math.log(value) / Math.log(base)); + } + + /** + * Returns a number raised to an exponent power. fBase^fExponent + * @param fBase The base value (IE 2) + * @param fExponent The exponent value (IE 3) + * @return base raised to exponent (IE 8) + * @see java.lang.Math#pow(double, double) + */ + public static float pow(float fBase, float fExponent) { + return (float) Math.pow(fBase, fExponent); + } + + /** + * Returns the value squared. fValue ^ 2 + * @param fValue The vaule to square. + * @return The square of the given value. + */ + public static float sqr(float fValue) { + return fValue * fValue; + } + + /** + * Returns the square root of a given value. + * @param fValue The value to sqrt. + * @return The square root of the given value. + * @see java.lang.Math#sqrt(double) + */ + public static float sqrt(float fValue) { + return (float) Math.sqrt(fValue); + } + + /** + * Returns the tangent of a value. If USE_FAST_TRIG is enabled, an approximate value + * is returned. Otherwise, a direct value is used. + * @param fValue The value to tangent, in radians. + * @return The tangent of fValue. + * @see java.lang.Math#tan(double) + */ + public static float tan(float fValue) { + return (float) Math.tan(fValue); + } + + /** + * Returns 1 if the number is positive, -1 if the number is negative, and 0 otherwise + * @param iValue The integer to examine. + * @return The integer's sign. + */ + public static int sign(int iValue) { + if (iValue > 0) { + return 1; + } + if (iValue < 0) { + return -1; + } + return 0; + } + + /** + * Returns 1 if the number is positive, -1 if the number is negative, and 0 otherwise + * @param fValue The float to examine. + * @return The float's sign. + */ + public static float sign(float fValue) { + return Math.signum(fValue); + } + + /** + * Given 3 points in a 2d plane, this function computes if the points going from A-B-C + * are moving counter clock wise. + * @param p0 Point 0. + * @param p1 Point 1. + * @param p2 Point 2. + * @return 1 If they are CCW, -1 if they are not CCW, 0 if p2 is between p0 and p1. + */ + public static int counterClockwise(Vector2f p0, Vector2f p1, Vector2f p2) { + float dx1, dx2, dy1, dy2; + dx1 = p1.x - p0.x; + dy1 = p1.y - p0.y; + dx2 = p2.x - p0.x; + dy2 = p2.y - p0.y; + if (dx1 * dy2 > dy1 * dx2) { + return 1; + } + if (dx1 * dy2 < dy1 * dx2) { + return -1; + } + if ((dx1 * dx2 < 0) || (dy1 * dy2 < 0)) { + return -1; + } + if ((dx1 * dx1 + dy1 * dy1) < (dx2 * dx2 + dy2 * dy2)) { + return 1; + } + return 0; + } + + /** + * Test if a point is inside a triangle. 1 if the point is on the ccw side, + * -1 if the point is on the cw side, and 0 if it is on neither. + * @param t0 First point of the triangle. + * @param t1 Second point of the triangle. + * @param t2 Third point of the triangle. + * @param p The point to test. + * @return Value 1 or -1 if inside triangle, 0 otherwise. + */ + public static int pointInsideTriangle(Vector2f t0, Vector2f t1, Vector2f t2, Vector2f p) { + int val1 = counterClockwise(t0, t1, p); + if (val1 == 0) { + return 1; + } + int val2 = counterClockwise(t1, t2, p); + if (val2 == 0) { + return 1; + } + if (val2 != val1) { + return 0; + } + int val3 = counterClockwise(t2, t0, p); + if (val3 == 0) { + return 1; + } + if (val3 != val1) { + return 0; + } + return val3; + } + + /** + * A method that computes normal for a triangle defined by three vertices. + * @param v1 first vertex + * @param v2 second vertex + * @param v3 third vertex + * @return a normal for the face + */ + public static Vector3f computeNormal(Vector3f v1, Vector3f v2, Vector3f v3) { + Vector3f a1 = v1.subtract(v2); + Vector3f a2 = v3.subtract(v2); + return a2.crossLocal(a1).normalizeLocal(); + } + + /** + * Returns the determinant of a 4x4 matrix. + */ + public static float determinant(double m00, double m01, double m02, + double m03, double m10, double m11, double m12, double m13, + double m20, double m21, double m22, double m23, double m30, + double m31, double m32, double m33) { + + double det01 = m20 * m31 - m21 * m30; + double det02 = m20 * m32 - m22 * m30; + double det03 = m20 * m33 - m23 * m30; + double det12 = m21 * m32 - m22 * m31; + double det13 = m21 * m33 - m23 * m31; + double det23 = m22 * m33 - m23 * m32; + return (float) (m00 * (m11 * det23 - m12 * det13 + m13 * det12) - m01 + * (m10 * det23 - m12 * det03 + m13 * det02) + m02 + * (m10 * det13 - m11 * det03 + m13 * det01) - m03 + * (m10 * det12 - m11 * det02 + m12 * det01)); + } + + /** + * Returns a random float between 0 and 1. + * + * @return A random float between 0.0f (inclusive) to + * 1.0f (exclusive). + */ + public static float nextRandomFloat() { + return rand.nextFloat(); + } + + /** + * Returns a random integer between min and max. + * + * @return A random int between min (inclusive) to + * max (inclusive). + */ + public static int nextRandomInt(int min, int max) { + return (int) (nextRandomFloat() * (max - min + 1)) + min; + } + + public static int nextRandomInt() { + return rand.nextInt(); + } + + /** + * Converts a point from Spherical coordinates to Cartesian (using positive + * Y as up) and stores the results in the store var. + */ + public static Vector3f sphericalToCartesian(Vector3f sphereCoords, + Vector3f store) { + store.y = sphereCoords.x * FastMath.sin(sphereCoords.z); + float a = sphereCoords.x * FastMath.cos(sphereCoords.z); + store.x = a * FastMath.cos(sphereCoords.y); + store.z = a * FastMath.sin(sphereCoords.y); + + return store; + } + + /** + * Converts a point from Cartesian coordinates (using positive Y as up) to + * Spherical and stores the results in the store var. (Radius, Azimuth, + * Polar) + */ + public static Vector3f cartesianToSpherical(Vector3f cartCoords, + Vector3f store) { + float x = cartCoords.x; + if (x == 0) { + x = FastMath.FLT_EPSILON; + } + store.x = FastMath.sqrt((x * x) + + (cartCoords.y * cartCoords.y) + + (cartCoords.z * cartCoords.z)); + store.y = FastMath.atan(cartCoords.z / x); + if (x < 0) { + store.y += FastMath.PI; + } + store.z = FastMath.asin(cartCoords.y / store.x); + return store; + } + + /** + * Converts a point from Spherical coordinates to Cartesian (using positive + * Z as up) and stores the results in the store var. + */ + public static Vector3f sphericalToCartesianZ(Vector3f sphereCoords, + Vector3f store) { + store.z = sphereCoords.x * FastMath.sin(sphereCoords.z); + float a = sphereCoords.x * FastMath.cos(sphereCoords.z); + store.x = a * FastMath.cos(sphereCoords.y); + store.y = a * FastMath.sin(sphereCoords.y); + + return store; + } + + /** + * Converts a point from Cartesian coordinates (using positive Z as up) to + * Spherical and stores the results in the store var. (Radius, Azimuth, + * Polar) + */ + public static Vector3f cartesianZToSpherical(Vector3f cartCoords, + Vector3f store) { + float x = cartCoords.x; + if (x == 0) { + x = FastMath.FLT_EPSILON; + } + store.x = FastMath.sqrt((x * x) + + (cartCoords.y * cartCoords.y) + + (cartCoords.z * cartCoords.z)); + store.z = FastMath.atan(cartCoords.z / x); + if (x < 0) { + store.z += FastMath.PI; + } + store.y = FastMath.asin(cartCoords.y / store.x); + return store; + } + + /** + * Takes an value and expresses it in terms of min to max. + * + * @param val - + * the angle to normalize (in radians) + * @return the normalized angle (also in radians) + */ + public static float normalize(float val, float min, float max) { + if (Float.isInfinite(val) || Float.isNaN(val)) { + return 0f; + } + float range = max - min; + while (val > max) { + val -= range; + } + while (val < min) { + val += range; + } + return val; + } + + /** + * @param x + * the value whose sign is to be adjusted. + * @param y + * the value whose sign is to be used. + * @return x with its sign changed to match the sign of y. + */ + public static float copysign(float x, float y) { + if (y >= 0 && x <= -0) { + return -x; + } else if (y < 0 && x >= 0) { + return -x; + } else { + return x; + } + } + + /** + * Take a float input and clamp it between min and max. + * + * @param input + * @param min + * @param max + * @return clamped input + */ + public static float clamp(float input, float min, float max) { + return (input < min) ? min : (input > max) ? max : input; + } + + /** + * Clamps the given float to be between 0 and 1. + * + * @param input + * @return input clamped between 0 and 1. + */ + public static float saturate(float input) { + return clamp(input, 0f, 1f); + } + + /** + * Converts a single precision (32 bit) floating point value + * into half precision (16 bit). + * + *

Source: + * http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
broken link + * + * @param half The half floating point value as a short. + * @return floating point value of the half. + */ + public static float convertHalfToFloat(short half) { + switch ((int) half) { + case 0x0000: + return 0f; + case 0x8000: + return -0f; + case 0x7c00: + return Float.POSITIVE_INFINITY; + case 0xfc00: + return Float.NEGATIVE_INFINITY; + // TODO: Support for NaN? + default: + return Float.intBitsToFloat(((half & 0x8000) << 16) + | (((half & 0x7c00) + 0x1C000) << 13) + | ((half & 0x03FF) << 13)); + } + } + + public static short convertFloatToHalf(float flt) { + if (Float.isNaN(flt)) { + throw new UnsupportedOperationException("NaN to half conversion not supported!"); + } else if (flt == Float.POSITIVE_INFINITY) { + return (short) 0x7c00; + } else if (flt == Float.NEGATIVE_INFINITY) { + return (short) 0xfc00; + } else if (flt == 0f) { + return (short) 0x0000; + } else if (flt == -0f) { + return (short) 0x8000; + } else if (flt > 65504f) { + // max value supported by half float + return 0x7bff; + } else if (flt < -65504f) { + return (short) (0x7bff | 0x8000); + } else if (flt > 0f && flt < 5.96046E-8f) { + return 0x0001; + } else if (flt < 0f && flt > -5.96046E-8f) { + return (short) 0x8001; + } + + int f = Float.floatToIntBits(flt); + return (short) (((f >> 16) & 0x8000) + | ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) + | ((f >> 13) & 0x03ff)); + } +}