Added faster math functions

src/gl_engine/MathHelpers.java

@@ -6,6 +6,75 @@ import gl_engine.vec.Vec3d;
 public class MathHelpers
 {
 	public static final double FallSpeed = 0.00098;
+	private static double[] TRIG_SIN_VALUES = null;
+	private static double[] TRIG_ASIN_VALUES = null;
+	
+	public static final double PI = 3.1415926535897932384626;
+	public static final double TWO_PI = PI * 2;
+	public static final double HALF_PI = PI / 2;
+	
+	public static void init()
+	{
+		// Initialize by default with 8 MB of trig values
+		init(1048576);
+	}
+	
+	public static void init(int size)
+	{
+		TRIG_SIN_VALUES = new double[size];
+		TRIG_ASIN_VALUES = new double[size];
+		
+		for(int i=0;i<size;i++) {
+			TRIG_SIN_VALUES[i] = Math.sin((i / (double)size) * TWO_PI);
+			TRIG_ASIN_VALUES[i] = HALF_PI - Math.asin(((2 * i) / (double)size) - 1);
+		}
+	}
+	
+	public static double sin(double a) {
+		return TRIG_SIN_VALUES[(int)((mod(a, TWO_PI) / TWO_PI) * TRIG_SIN_VALUES.length)];
+	}
+	
+	public static double cos(double a) {
+		return sin(a + HALF_PI);
+	}
+	
+	public static double tan(double a) {
+		return sin(a) / sin(a + HALF_PI);
+	}
+	
+	public static double asin(double a) {
+		if(a < -1 || a > 1) return Double.NaN;
+		return TRIG_ASIN_VALUES[(int)((a + 1) / (2 * TRIG_ASIN_VALUES.length))];
+	}
+	
+	public static double acos(double a) {
+		return HALF_PI - asin(a);
+	}
+	
+	public static double atan(double a) {
+		return Math.atan(a);
+	}
+	
+	public static double atan2(double y, double x)
+	{
+		if(x > 0) return tan(y / x);
+		
+		if(x < 0) {
+			if(y >= 0) return tan(y / x) + PI;
+			if(y < 0) return tan(y / x) - PI;
+		};
+
+		if(x == 0) {
+			if(y > 0) return HALF_PI;
+			if(y < 0) return -HALF_PI;
+		}
+		
+		return Double.NaN;
+	}
+	
+	public static double sqrt(double a) {
+		return Math.sqrt(a);
+	}
 	
 	public static double nextPowerOf(double x, double n)
 	{
@@ -45,11 +114,11 @@ public class MathHelpers
 	}
 	
 	public static double distance3d(double x1, double y1, double z1, double x2, double y2, double z2) {
-		return Math.sqrt( squared(x2 - x1) + squared(y2 - y1) + squared(z2 - z1) );
+		return MathHelpers.sqrt( squared(x2 - x1) + squared(y2 - y1) + squared(z2 - z1) );
 	}
 	
 	public static double distance2d(double x1, double y1, double x2, double y2) {
-		return Math.sqrt( squared(x2 - x1) + squared(y2 - y1) );
+		return MathHelpers.sqrt( squared(x2 - x1) + squared(y2 - y1) );
 	}
 	
 	public static double map(double x, double in_min, double in_max, double out_min, double out_max) {
@@ -57,7 +126,7 @@ public class MathHelpers
 	}
 	
 	public static Vec2d moveTowards2(double amount, double angle) {
-		return new Vec2d(Math.sin(angle) * amount, Math.cos(angle) * amount);
+		return new Vec2d(sin(angle) * amount, cos(angle) * amount);
 	}
 	
 	public static Vec3d moveTowards3(double amount, Vec2d angles)
@@ -66,10 +135,10 @@ public class MathHelpers
 	    Vec3d points = new Vec3d(0, 0, 0);
 	    double m;
 	    
-	    points.z = Math.sin(angles.y) * amount;
+	    points.z = sin(angles.y) * amount;
-	    m = Math.cos(angles.y);
+	    m = cos(angles.y);
-	    points.x = Math.sin(angles.x) * m * amount;
+	    points.x = sin(angles.x) * m * amount;
-	    m = Math.cos(angles.x) * m;
+	    m = cos(angles.x) * m;
 	    points.y = m * amount;
 
 	    return points;
@@ -111,8 +180,8 @@ public class MathHelpers
 	public static Vec2d rotate2(Vec2d pos, double angle)
 	{
 		// Calculate 2 sin and cos values
-		double s = Math.sin(angle);
+		double s = sin(angle);
-		double c = Math.cos(angle);
+		double c = cos(angle);
 		
 		// Return and calculate the new positions
 		return new Vec2d(

src/gl_engine/matrix/Matrix4.java

@@ -2,6 +2,7 @@ package gl_engine.matrix;
 
 import bdf.classes.IBdfClassManager;
 import bdf.types.BdfObject;
+import gl_engine.MathHelpers;
 import gl_engine.vec.Vec3d;
 
 public class Matrix4 implements IBdfClassManager
@@ -51,8 +52,8 @@ public class Matrix4 implements IBdfClassManager
 		Matrix4 result = identity();
 		
 		double angle_rad = Math.toRadians(angle);
-		double sin = Math.sin(angle_rad);
+		double sin = MathHelpers.sin(angle_rad);
-		double cos = Math.cos(angle_rad);
+		double cos = MathHelpers.cos(angle_rad);
 		double icos = 1 - cos;
 		
 		result.set(0, 0, cos + x * x * icos);
@@ -127,7 +128,7 @@ public class Matrix4 implements IBdfClassManager
 	
 	public static Matrix4 projection(double aspect, double fov, double near, double far)
 	{
-		double tan = Math.tan(Math.toRadians(fov / 2.0));
+		double tan = MathHelpers.tan(Math.toRadians(fov / 2.0));
 		double diff = far - near;
 		
 		Matrix4 result = identity();

src/gl_engine/vec/Vec2d.java

@@ -28,7 +28,7 @@ public class Vec2d implements IBdfClassManager
 	}
 	
 	public double length() {
-		return Math.sqrt(x*x + y*y);
+		return MathHelpers.sqrt(x*x + y*y);
 	}
 	
 	public Vec2d normalize() {

src/gl_engine/vec/Vec3d.java

@@ -34,7 +34,7 @@ public class Vec3d implements IBdfClassManager
 	}
 	
 	public double length() {
-		return Math.sqrt(x*x + y*y + z*z);
+		return MathHelpers.sqrt(x*x + y*y + z*z);
 	}
 	
 	public Vec3d normalize() {

src/gl_engine/vec/Vec4d.java

@@ -44,7 +44,7 @@ public class Vec4d implements IBdfClassManager
 	}
 	
 	public double distance(Vec4d other) {
-		return Math.sqrt(
+		return MathHelpers.sqrt(
 				MathHelpers.squared(this.x - other.x) +
 				MathHelpers.squared(this.y - other.y) +
 				MathHelpers.squared(this.z - other.z) +
@@ -56,7 +56,7 @@ public class Vec4d implements IBdfClassManager
 	}
 	
 	public double length() {
-		return Math.sqrt(x*x + y*y + z*z + m*m);
+		return MathHelpers.sqrt(x*x + y*y + z*z + m*m);
 	}
 	
 	public Vec4d normalize() {

src/gl_engine/vec/Vec4i.java

@@ -45,7 +45,7 @@ public class Vec4i implements IBdfClassManager
 	}
 	
 	public double distance(Vec4i other) {
-		return Math.sqrt(
+		return MathHelpers.sqrt(
 				MathHelpers.squared(this.x - other.x) +
 				MathHelpers.squared(this.y - other.y) +
 				MathHelpers.squared(this.z - other.z) +