melonjs 14.0.2 → 14.1.1

package/dist/melonjs.mjs/tweens/easing.js

@@ -0,0 +1,336 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+/*
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ */
+
+/* eslint-disable quotes, keyword-spacing, comma-spacing, no-return-assign */
+
+/**
+ * Easing Function :<br>
+ * <p>
+ * Easing.Linear.None<br>
+ * Easing.Quadratic.In<br>
+ * Easing.Quadratic.Out<br>
+ * Easing.Quadratic.InOut<br>
+ * Easing.Cubic.In<br>
+ * Easing.Cubic.Out<br>
+ * Easing.Cubic.InOut<br>
+ * Easing.Quartic.In<br>
+ * Easing.Quartic.Out<br>
+ * Easing.Quartic.InOut<br>
+ * Easing.Quintic.In<br>
+ * Easing.Quintic.Out<br>
+ * Easing.Quintic.InOut<br>
+ * Easing.Sinusoidal.In<br>
+ * Easing.Sinusoidal.Out<br>
+ * Easing.Sinusoidal.InOut<br>
+ * Easing.Exponential.In<br>
+ * Easing.Exponential.Out<br>
+ * Easing.Exponential.InOut<br>
+ * Easing.Circular.In<br>
+ * Easing.Circular.Out<br>
+ * Easing.Circular.InOut<br>
+ * Easing.Elastic.In<br>
+ * Easing.Elastic.Out<br>
+ * Easing.Elastic.InOut<br>
+ * Easing.Back.In<br>
+ * Easing.Back.Out<br>
+ * Easing.Back.InOut<br>
+ * Easing.Bounce.In<br>
+ * Easing.Bounce.Out<br>
+ * Easing.Bounce.InOut
+ * </p>
+ * @public
+ * @constant
+ * @enum {Function}
+ * @name Easing
+ * @memberof Tween
+ */
+let Easing = {
+
+    Linear: {
+        /** @ignore */
+        None: function ( k ) {
+
+            return k;
+
+        }
+
+    },
+
+    Quadratic: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return k * k;
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return k * ( 2 - k );
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( ( k *= 2 ) < 1 ) return 0.5 * k * k;
+            return - 0.5 * ( --k * ( k - 2 ) - 1 );
+
+        }
+
+    },
+
+    Cubic: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return k * k * k;
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return --k * k * k + 1;
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k;
+            return 0.5 * ( ( k -= 2 ) * k * k + 2 );
+
+        }
+
+    },
+
+    Quartic: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return k * k * k * k;
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return 1 - ( --k * k * k * k );
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( ( k *= 2 ) < 1) return 0.5 * k * k * k * k;
+            return - 0.5 * ( ( k -= 2 ) * k * k * k - 2 );
+
+        }
+
+    },
+
+    Quintic: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return k * k * k * k * k;
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return --k * k * k * k * k + 1;
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k * k * k;
+            return 0.5 * ( ( k -= 2 ) * k * k * k * k + 2 );
+
+        }
+
+    },
+
+    Sinusoidal: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return 1 - Math.cos( k * Math.PI / 2 );
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return Math.sin( k * Math.PI / 2 );
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            return 0.5 * ( 1 - Math.cos( Math.PI * k ) );
+
+        }
+
+    },
+
+    Exponential: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return k === 0 ? 0 : Math.pow( 1024, k - 1 );
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return k === 1 ? 1 : 1 - Math.pow( 2, - 10 * k );
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( k === 0 ) return 0;
+            if ( k === 1 ) return 1;
+            if ( ( k *= 2 ) < 1 ) return 0.5 * Math.pow( 1024, k - 1 );
+            return 0.5 * ( - Math.pow( 2, - 10 * ( k - 1 ) ) + 2 );
+
+        }
+
+    },
+
+    Circular: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return 1 - Math.sqrt( 1 - k * k );
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            return Math.sqrt( 1 - ( --k * k ) );
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( ( k *= 2 ) < 1) return - 0.5 * ( Math.sqrt( 1 - k * k) - 1);
+            return 0.5 * ( Math.sqrt( 1 - ( k -= 2) * k) + 1);
+
+        }
+
+    },
+
+    Elastic: {
+        /** @ignore */
+        In: function ( k ) {
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
+        },
+        /** @ignore */
+        Out: function ( k ) {
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1;
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+            if (k === 0) {
+                return 0;
+            }
+            if (k === 1) {
+                return 1;
+            }
+            k *= 2;
+            if (k < 1) {
+                return -0.5 * Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
+            }
+            return 0.5 * Math.pow(2, -10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI) + 1;
+        }
+
+    },
+
+    Back: {
+        /** @ignore */
+        In: function ( k ) {
+
+            var s = 1.70158;
+            return k * k * ( ( s + 1 ) * k - s );
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            var s = 1.70158;
+            return --k * k * ( ( s + 1 ) * k + s ) + 1;
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            var s = 1.70158 * 1.525;
+            if ( ( k *= 2 ) < 1 ) return 0.5 * ( k * k * ( ( s + 1 ) * k - s ) );
+            return 0.5 * ( ( k -= 2 ) * k * ( ( s + 1 ) * k + s ) + 2 );
+
+        }
+
+    },
+
+    Bounce: {
+        /** @ignore */
+        In: function ( k ) {
+
+            return 1 - Easing.Bounce.Out( 1 - k );
+
+        },
+        /** @ignore */
+        Out: function ( k ) {
+
+            if ( k < ( 1 / 2.75 ) ) {
+
+                return 7.5625 * k * k;
+
+            } else if ( k < ( 2 / 2.75 ) ) {
+
+                return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
+
+            } else if ( k < ( 2.5 / 2.75 ) ) {
+
+                return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
+
+            } else {
+
+                return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
+
+            }
+
+        },
+        /** @ignore */
+        InOut: function ( k ) {
+
+            if ( k < 0.5 ) return Easing.Bounce.In( k * 2 ) * 0.5;
+            return Easing.Bounce.Out( k * 2 - 1 ) * 0.5 + 0.5;
+
+        }
+
+    }
+
+};
+
+export { Easing };

package/dist/melonjs.mjs/tweens/interpolation.js

@@ -0,0 +1,112 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+/*
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ */
+
+/**
+ * Interpolation Function :<br>
+ * <p>
+ * Interpolation.Linear<br>
+ * Interpolation.Bezier<br>
+ * Interpolation.CatmullRom
+ * </p>
+ * @public
+ * @constant
+ * @enum {Function}
+ * @name Interpolation
+ * @memberof Tween
+ */
+let Interpolation = {
+    /** @ignore */
+    Linear: function ( v, k ) {
+
+        var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = Interpolation.Utils.Linear;
+
+        if ( k < 0 ) return fn( v[ 0 ], v[ 1 ], f );
+        if ( k > 1 ) return fn( v[ m ], v[ m - 1 ], m - f );
+
+        return fn( v[ i ], v[ i + 1 > m ? m : i + 1 ], f - i );
+
+    },
+    /** @ignore */
+    Bezier: function ( v, k ) {
+
+        var b = 0, n = v.length - 1, pw = Math.pow, bn = Interpolation.Utils.Bernstein, i;
+
+        for ( i = 0; i <= n; i++ ) {
+            b += pw( 1 - k, n - i ) * pw( k, i ) * v[ i ] * bn( n, i );
+        }
+
+        return b;
+
+    },
+    /** @ignore */
+    CatmullRom: function ( v, k ) {
+
+        var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = Interpolation.Utils.CatmullRom;
+
+        if ( v[ 0 ] === v[ m ] ) {
+
+            if ( k < 0 ) i = Math.floor( f = m * ( 1 + k ) );
+
+            return fn( v[ ( i - 1 + m ) % m ], v[ i ], v[ ( i + 1 ) % m ], v[ ( i + 2 ) % m ], f - i );
+
+        } else {
+
+            if ( k < 0 ) return v[ 0 ] - ( fn( v[ 0 ], v[ 0 ], v[ 1 ], v[ 1 ], -f ) - v[ 0 ] );
+            if ( k > 1 ) return v[ m ] - ( fn( v[ m ], v[ m ], v[ m - 1 ], v[ m - 1 ], f - m ) - v[ m ] );
+
+            return fn( v[ i ? i - 1 : 0 ], v[ i ], v[ m < i + 1 ? m : i + 1 ], v[ m < i + 2 ? m : i + 2 ], f - i );
+
+        }
+
+    },
+
+    Utils: {
+        /** @ignore */
+        Linear: function ( p0, p1, t ) {
+
+            return ( p1 - p0 ) * t + p0;
+
+        },
+        /** @ignore */
+        Bernstein: function ( n, i ) {
+
+            var fc = Interpolation.Utils.Factorial;
+            return fc( n ) / fc( i ) / fc( n - i );
+
+        },
+        /* @ignore */
+        Factorial: ( function () {
+
+            var a = [ 1 ];
+
+            return function ( n ) {
+
+                var s = 1, i;
+                if ( a[ n ] ) return a[ n ];
+                for ( i = n; i > 1; i-- ) s *= i;
+                a[ n ] = s;
+                return s;
+
+            };
+
+        } )(),
+        /** @ignore */
+        CatmullRom: function ( p0, p1, p2, p3, t ) {
+
+            var v0 = ( p2 - p0 ) * 0.5, v1 = ( p3 - p1 ) * 0.5, t2 = t * t, t3 = t * t2;
+            return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
+        }
+    }
+
+};
+
+export { Interpolation };