Returns the absolute value of the supplied number.

Returns the arc cosine of the angle.

Signed angle between two vectors, in radians. Therefore, does not use "Dot", which would yield the same answer if the two vectors were switched. If accumulate this around a closed shape, can determine whether "winding" is clockwise or counter-clockwise.

Returns the arc sine of the angle.

Return X and Z. When Height is in Y!

Calculate a Vector3 position along a Bezier Curve

Builds a reflection matrix for the specified plane.

Calculate a face normal from 3 points, providing no w-information.

Calculate a face normal from 3 points on a plane. Result includes the w component which is the offset from the origin.

Calculates the tangent space vector for a given set of positions / texture coords.

Division, rounding fractional part up. ASSERT: "result * divisor >= value"; "(result - 1) * divisor lt value". Use this when dividing into equal parts, and is better to be slightly larger than slightly smaller.

Like Ceiling, but to multiple of StepSize value (e.g. "Ceiling 131 to multiple of 5" == 135).

Like Ceiling, but to multiple of StepSize value (e.g. "Ceiling 131 to multiple of 5" == 135).

Return value is based on proposedValue, but maxChange limits how much the result can differ from oldValue. (maxChange should not be negative.)

Return value is based on proposedValue, but maxChange limits how much the result can differ from oldValue. (maxChange should not be negative.)

Clamp "Abs(val)" to "absMax".

Do not allow to be below "min". (Intent clearer than using "Math.Max()".)

Do not allow to be below "min". (Intent clearer than using "Math.Max()".)

Do not allow to be below "min". (Intent clearer than using "Math.Max()".)

Clamps the point to the defined Boundary Box. Returns 'true' is clamping action was required, else 'false' if point was already inside the bounds.

Modifies a point to ensure it remains within a specified Rectangle

Modifies a point to ensure it remains within a specified Rectangle

Modifies a value to ensure it remains between a specified minimum and maximum value.

Modifies a value to ensure it remains between a specified minimum and maximum value.

Modifies a value to ensure it remains between a specified minimum and maximum value.

Modifies a value to ensure it remains between a specified minimum and maximum value.

Modifies a point to ensure it remains within a rectangle specified as x, y, width and height.

Modifies a value to ensure it remains between -1 and 1.

Modifies a value to ensure it remains between -1 and 1.

Modifies a value to ensure it remains between 0 and 1.

Modifies a value to ensure it remains between 0 and 1.

Modifies a value to ensure it remains between -100 and 100.

Modifies a value to ensure it remains between -100 and 100.

Modifies a value to ensure it remains between -100 and 100.

Modifies a value to ensure it remains between 0 and 100.

Modifies a value to ensure it remains between 0 and 100.

Modifies a value to ensure it remains between 0 and 100.

Returns the cosine of the angle.

Converts degrees to radians.

Diminish magnitude of "value" by "absChange". "absChange" is expected to be >= 0. If Abs(value) lt absChange, result is 0. Otherwise, is moved towards 0.

1-D equivalent of Distance for Vector2, Vector3.

Integer divide, returning nearest integer. (Built-in division does truncation.)

True if all 3 params are equal.

Returns the arctan of argument.

Returns the inverse square root of a number.

Returns the sine and cosine of the angle.

Fast floating point Tangent.

Compares float values for equality, taking into consideration that floating point values should never be directly compared using ==. 2 floats could be conceptually equal, but vary by a .000001 which would fail in a direct comparison. To circumvent that, a tolerance value is used to see if the difference between the 2 floats is less than the desired amount of accuracy.

Like Floor, but to multiple of StepSize value (e.g. "Floor 134 to multiple of 5" == 130).

Y (height) initialized to zero. Presumably, caller will fill in later, using GetHeightAt().

Gets the bottom center point of this bounding box.

Gets the bottom center point of this bounding box.

Gets the center point of this bounding box with an offset

Gets the center point of this bounding box.

Get's the Y-Dimension (aka "height") of the bounding box.

Get's the Y-Dimension (aka "height") of the bounding box.

Gets the top center point of this bounding box.

Gets the top center point of this bounding box.

Utility method which returns the count of scalar values in a given type of vertex element.

Returns size of given vertex element format in bytes.

Integer logarithm of modulo 2.

Project lines to XY-Plane; find intersection.

Project lines to XZ-Plane; find intersection.

Inverse square root.

Returns true if the value is not +/- infinity and not NaN

Returns 'true' if the value is zero or higher, but not Infinity nor NaN.

Returns true if the value is positive or negative infinity or NaN

Returns true if the value > 0, but not Infinity nor NaN.

Indicates if the size of this Box is invalid. "true" if any dimension is negative, infinity or not a number (NaN). Previous version returned "true" if ANY dimension was zero. TMS 31-Aug-2010: Changed to be "true" if has no thickness, but !IsZero. Reason: May still be visible, so wish to include when merging.

Indicates if the size and position of the box are zero (Min=Max={0,0,0}).

Indicates if the size of this Box is Zero (i.e. Min == Max).

Weighted Average of two numbers. When wgt==0, returns a, when wgt==1, returns b.

SIDE-EFFECT: dstData becomes result. Each dst element receives Lerp(dst, src, wgtSrc). To be meaningful, dstData and srcData must have identical stride. REQUIRE srcData.Length == dstData.Length.

Weighted Average of two numbers. When wgt==0, returns a, when wgt==1, returns b.

Weighted Average of two numbers. When wgt==0, returns a, when wgt==1, returns b. NOTE: Identical to XNA MathHelper.Lerp.

SIDE-EFFECT: dstData becomes result. Each dst element receives Lerp(src1, src2, wgtSrc2). To be meaningful, src1Data, src2Data, and dstData must have identical stride. REQUIRE src1Data.Length == src2Data.Length == dstData.Length. ALLOW dstData may be same array as src1Data or src2Data.

SIDE-EFFECT: dst becomes result. Each dst element receives Lerp(src1, src2, wgtSrc2). To be meaningful, src1, src2, and dst must have identical stride. REQUIRE src1.Count == src2.Count == dst.Count. ALLOW dst may be same buffer as src1 or src2.

SIDE-EFFECT: dstData becomes result. Each dst element receives Lerp(src1, src2, wgtSrc2). To be meaningful, src1Data, src2Data, and dstData must have identical stride. REQUIRE src1Data.Length == src2Data.Length == dstData.Length. ALLOW dstData may be same array as src1Data or src2Data.

Builds a Matrix4 from orientation / scale / position.

Builds a Matrix4 from orientation / scale / position.

Builds a Matrix4 from orientation / scale / position.

TMS: Alternative to XNA's Matrix.Decompose. In case we stop using XNA. Source: Book "XNA Essentials", chapter 16 (on CD). Fixed trans bugs; added "orient" output. TODO: "Y" comes out negated compared to XNA.

Used to quickly determine the greater value between two values.

Used to quickly determine the greater value between two values.

Used to quickly determine the greater value between two values.

Used to quickly determine the greater value amoung three values.

Using Float Precision, closest value that can be achieved just below 1 (equals: 0.99999994f).

Return a BoundingBox which contains both box1 and box2, excluding any box with an invalid size (any dimension is 0, negative, or infinite).

Expands the result BoundingBox, if needed, to ensure that it contains additionToContain. Result is expanded only if additionToContain has a valid non-zero size (size in all dimensions is positive, non-zero, non-infinite value), or else set to additionToContain if it has valid size and result does not.

Expands the result BoundingBox, if needed, to ensure that it contains additionToContain. Result is expanded only if additionToContain has a valid non-zero size (size in all dimensions is positive, non-zero, non-infinite value), or else set to additionToContain if it has valid size and result does not.

Used to quickly determine the lesser value between two values.

Used to quickly determine the greater value between two values.

Used to quickly determine the greater value amoung three values.

Useful for finding bounds of group of points. minVec contains (independent) minimum of each coord; similar for maxVec.

Returns proper enum for vertex element format multiplied by a value.

This is unsafe but more efficient alternative to Matrix.Multiply(ref, ref, out) because the out result parameter cannot be the same as the inputs.

Since only one value each, For numbers near zero, treat as absolute scale, rather than ratio.

CAUTION: Only meaningful for target in range (-1,1). Otherwise, needs a tolerance that scales with the value.

CAUTION: Uses an absolute tolerance, not a scaled error term, so be careful, when values might be large, that tolerance is large enough to be distinguishable within a float value. E.g. "NearZero" is only meaningful tolerance for values in range (-1, 1).

More appropriate test (than NearlyEquals) for numbers that might exceed range [-1,1].

More appropriate test (than NearlyEquals) for numbers that might exceed range [-1,1].

Count of the leading zero bit.

Count of the amount of 1-bit.

Integer divide, returning nearest integer. REQUIRE positive number, divisor. (Built-in division does truncation.)

Converts radians to degrees.

Similar to built-in Random(int), but for floats. Returns float from 0 up to (but never quite reaching) limit.

Returns a random value between the specified min and max values.

Round, keeping specified number of fractional digits.

Round, keeping one fractional digit.

Round, keeping two fractional digits.

Round, keeping three fractional digits.

Ceiling, but in case number might be slightly high due to rounding errors, subtract a tiny amount first. For situations where don't want to unnecessarily go to next larger value. The opposite of "SafeCeiling". EX: Math.Ceiling(16.000000000000002) => 17, but RoundedCeiling => 16. NOTE: MathUtil.NearZero~=0.00000006. If 16.00000005 => 16 is an excessive rounding for you, then make a version that accepts a tolerance parameter, in place of hard-wired "NearZero". Conversely, "float" calculations might want 10x or 100x NearZero, to overcome accumulated losses. NOTE: If number is from calculations involving large numbers, do careful testing to be sure this never produces a smaller answer than desired. (Concept: we are very close to an integer value, but slightly off due to approximate math. If it would be "expensive" or "misleading" to return a larger answer, we wish to avoid doing so if possible. If we had used exact math, we would have gotten exactly 16. However, this belief needs to be verified by testing.)

Floor, but in case number might be slightly low due to rounding errors, add a tiny amount first. For situations where don't want to unnecessarily go to next small value. EX: Math.Floor(15.999999999999998) => 15, but RoundedFloor => 16. NOTE: MathUtil.NearZero~=0.00000006. If 15.99999995 => 16 is an excessive rounding for you, then make a version that accepts a tolerance parameter, in place of hard-wired "NearZero". NOTE: If number is from calculations involving large numbers, do careful testing to be sure this never produces a larger answer than desired. (Concept: we are very close to an integer value, but slightly off due to approximate math. If it would be "expensive" or "misleading" to return a smaller answer, we wish to avoid doing so if possible. If we had used exact math, we would have gotten exactly 16. However, this belief needs to be verified by testing.)

Rounds Number to nearest multiple of StepSize value (e.g. "Round 134 to the nearest 5" == 135).

Rounds up to nearest power of two, if x is not already one, or returns 0 if x is 0 or negative.

Conservative calculation that makes SURE you have a safely large answer. Even if this means unnecessarily increasing the result. The opposite of "RoundedCeiling". Ceiling, but in case number might be slightly low due to rounding errors, add a tiny amount first. EX: Math.Ceiling(15.999999999999998) => 16, but SafeCeiling => 17. (Concept: "this close" to 16, given approximate math, we aren't SURE 16 is high enough to be safe. Maybe exact math would have resulted in a number slightly above 16. If we need to be sure we have an "upper bound", we increase to 17.)

Conservative calculation that makes SURE you have a safely small answer. Even if this means unnecessarily decreasing the result. The opposite of "RoundedFloor". Ceiling, but in case number might be slightly high due to rounding errors, subtract a tiny amount first. EX: Math.Floor(16.000000000000002) => 16, but SafeFloor => 15. (Concept: "this close" to 16, given approximate math, we aren't SURE 16 is low enough to be safe. Maybe exact math would have resulted in a number slightly below 16. If we need an ironclad guarantee of "lower bound", then we drop to 15.)

Returns value * multiplier, if multiplier != 0, otherwise returns value.

Returns value * multiplier, if multiplier != 0, otherwise returns value.

Returns value * multiplier, if multiplier > 0, otherwise returns value.

Returns value * multiplier, if multiplier > 0, otherwise returns value.

Method calculates the value using Exponential-type accelerations, producing higher magnitudes for quicker changes in value.

Returns the sine of the angle.

Returns the square root of a number.

Returns the tangent of the angle.

For situations (such as matrix compose/decompose) where errors may be significantly larger than last bit.

Transforms all of the corners of this Box by the Matrix, causing it to become the new Box which encompasses the rotated version of itself.

Transforms all of the corners of this Box by the Matrix, causing it to become the new Box which encompasses the rotated version of itself.

Differs from Math.Truncate when number is negative. E.g. "-0.1" returns "-1" instead of "0" ("towards negative infinity" instead of "towards zero".)

Calculate wgt that would return result, if did Lerp(a, b, wgt). That is, where result is, w.r.t. a and b. less 0 is before a, greater 1 is after b.

Clamps given value into allowed range, by adding or subtracting (upperBound-lowerBound) from the value depending on whether or not value fits into the range.

Clamps given value into allowed range, by adding or subtracting (upperBound-lowerBound) from the value depending on whether or not value fits into the range.