Awesome

Mathf

Unity3D's Mathf port

What is this?

This is js port of Unity3D's Mathf class. It has been achieved by reverse engineering the work of original class and all the ported methods work exactly the same (except PerlinNoise method, cuz of different random realization and seed value). You can use this library in game development or in any other cases where you find existing methods useful.

Which platform should I use?

Originally it is node plugin serving by npm and using available ES6 features, but you can easily adopt it to work in browser with help of Babel or another ES6 transpiler.

What's not included

Useless within javascript methods:

CeilToInt
FloorToInt
RoundToInt

Built-in js native methods and constants:

Infinity
PI
Abs
Acos
Asin
Atan
Atan2
Ceil
Cos
Exp
Floor
Log
Log10
Max
Min
Pow
Sin
Sqrt
Tan

Note: Unity3D's Mathf.Round has different behavior then native javascript's Math.round, so this method has own implementation Mathf.round

What's included?

This port includes almost (read below why) all non default (for native js) methods and properties available in the Unity3D's Mathf class. Namely:

Static Variables

`Deg2Rad`

Degrees-to-radians conversion constant

`Epsilon`

A tiny floating point value

`NegativeInfinity`

A representation of negative infinity

`Rad2Deg`

Radians-to-degrees conversion constant

Static Functions

`approximately(f1, f2)`

Compares two floating point values if they are similar

`clamp(value, min, max)`

Clamps a value between a minimum float and maximum float value

`clamp01(value)`

Clamps value between 0 and 1 and returns value

`closestPowerOfTwo(value)`

Returns the closest power of two value

`deltaAngle(current, target)`

Calculates the shortest difference between two given angles given in degrees

`gammaToLinearSpace(value)`

Converts the given value from gamma (sRGB) to linear color space

`inverseLerp(a, b, value)`

Calculates the linear parameter t that produces the interpolant value within the range [a, b]

`isPowerOfTwo(value)`

Returns true if the value is power of two

`lerp(a, b, t)`

Linearly interpolates between a and b by t

`lerpAngle(a, b, t)`

Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees

`lerpUnclamped(a, b, t)`

Linearly interpolates between a and b by t

`linearToGammaSpace(value)`

Converts the given value from linear to gamma (sRGB) color space

`moveTowards(current, target , maxDelta)`

Moves a value current towards target

`nextPowerOfTwo(value)`

Returns the next power of two value

`perlinNoise(x, y)`

Generate 2D Perlin noise

`pingPong(t, length)`

PingPongs the value t, so that it is never larger than length and never smaller than 0

`repeat(t, length)`

Loops the value t, so that it is never larger than length and never smaller than 0

`round(f)`

Returns f rounded to the nearest integer

`sign(f)`

Returns the sign of f

Not ported methods

I didn't find proper implementations for them, so if you know it welcome to PR

`moveTowardsAngle(current, target, maxDelta)`

Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees

`smoothDamp(current, target, currentVelocity, smoothTime, maxSpeed, deltaTime)`

Gradually changes a value towards a desired goal over time

`smoothDampAngle(current, target, currentVelocity, smoothTime, maxSpeed, deltaTime)`

Gradually changes an angle given in degrees towards a desired goal angle over time

`smoothStep(a, b, t)`

Interpolates between min and max with smoothing at the limits

Additional

`closestPowerOfTwoLong(value)`

Same as closestPowerOfTwo, but deals well with big numbers. Use it if you really need to work with big numbers

How to use?

As simple as usual node module

Install it: npm install mathf
Require it:

let Mathf = require('mathf');
let rad = 2;

console.log(rad + ' radians are equal to ' + (rad * Mathf.Rad2Deg) + ' degrees');
// 2 radians are equal to 114.59155902616465 degrees