starling-framework/lib/_gen/starling/utils/MathUtil.js

A fast, productive library for 2D cross-platform development.

// Class: starling.utils.MathUtil

var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this

$global.Object.defineProperty(exports, "__esModule", {value: true});

var __map_reserved = {};

// Imports

var $hxClasses = require("./../../hxClasses_stub").default;
var $hxEnums = require("./../../hxEnums_stub").default;
var $import = require("./../../import_stub").default;
function openfl_geom_Point() {return $import(require("openfl/geom/Point"));}
function Std() {return require("./../../Std");}

// Constructor

var MathUtil = function(){}

// Meta

MathUtil.__name__ = "starling.utils.MathUtil";
MathUtil.__isInterface__ = false;
MathUtil.prototype = {
	
};
MathUtil.prototype.__class__ = MathUtil.prototype.constructor = $hxClasses["starling.utils.MathUtil"] = MathUtil;

// Init



// Statics

MathUtil.intersectLineWithXYPlane = function(pointA,pointB,out) {
	if(out == null) {
		out = new (openfl_geom_Point().default)();
	}
	var vectorX = pointB.x - pointA.x;
	var vectorY = pointB.y - pointA.y;
	var vectorZ = pointB.z - pointA.z;
	var lambda = -pointA.z / vectorZ;
	out.x = pointA.x + lambda * vectorX;
	out.y = pointA.y + lambda * vectorY;
	return out;
}
MathUtil.isPointInTriangle = function(p,a,b,c) {
	var v0x = c.x - a.x;
	var v0y = c.y - a.y;
	var v1x = b.x - a.x;
	var v1y = b.y - a.y;
	var v2x = p.x - a.x;
	var v2y = p.y - a.y;
	var dot00 = v0x * v0x + v0y * v0y;
	var dot01 = v0x * v1x + v0y * v1y;
	var dot02 = v0x * v2x + v0y * v2y;
	var dot11 = v1x * v1x + v1y * v1y;
	var dot12 = v1x * v2x + v1y * v2y;
	var invDen = 1.0 / (dot00 * dot11 - dot01 * dot01);
	var u = (dot11 * dot02 - dot01 * dot12) * invDen;
	var v = (dot00 * dot12 - dot01 * dot02) * invDen;
	if(u >= 0 && v >= 0) {
		return u + v < 1;
	} else {
		return false;
	}
}
MathUtil.normalizeAngle = function(angle) {
	angle %= MathUtil.TWO_PI;
	if(angle < -Math.PI) {
		angle += MathUtil.TWO_PI;
	}
	if(angle > Math.PI) {
		angle -= MathUtil.TWO_PI;
	}
	return angle;
}
MathUtil.getNextPowerOfTwo = function(number) {
	if(Math.round(number) == number && number > 0 && ((Std().default).int(number) & (Std().default).int(number - 1)) == 0) {
		return (Std().default).int(number);
	} else {
		var result = 1;
		number -= 0.000000001;
		while(result < number) result <<= 1;
		return result;
	}
}
MathUtil.isEquivalent = function(a,b,epsilon) {
	if(epsilon == null) {
		epsilon = 0.0001;
	}
	if(a - epsilon < b) {
		return a + epsilon > b;
	} else {
		return false;
	}
}
MathUtil.max = function(a,b) {
	if(a > b) {
		return a;
	} else {
		return b;
	}
}
MathUtil.min = function(a,b) {
	if(a < b) {
		return a;
	} else {
		return b;
	}
}
MathUtil.clamp = function(value,min,max) {
	if(value < min) {
		return min;
	} else if(value > max) {
		return max;
	} else {
		return value;
	}
}
MathUtil.minValues = function(values) {
	if(values.length == 0) {
		return 0.0;
	}
	var min = values[0];
	var _g = 1;
	var _g1 = values.length;
	while(_g < _g1) {
		var i = _g++;
		if(values[i] < min) {
			min = values[i];
		}
	}
	return min;
}
MathUtil.deg2rad = function(deg) {
	return deg / 180.0 * Math.PI;
}
MathUtil.rad2deg = function(rad) {
	return rad / Math.PI * 180.0;
}
MathUtil.toFixed = function(value,precision) {
	var sign = value > 0 ? 1 : -1;
	var mult = precision <= 0 ? 1 : precision * 10;
	return (Std().default).string(sign * Math.round(value * mult) / mult);
}
MathUtil.TWO_PI = Math.PI * 2.0

// Export

exports.default = MathUtil;