Moved the Curves objects into their own folder and namespace and optimized the vector creation within them

Author: photonstorm

v3/src/math/interpolation/CubicBezierInterpolation.js

@@ -0,0 +1,37 @@
+function P0 (t, p)
+{
+    var k = 1 - t;
+
+    return k * k * k * p;
+}
+
+function P1 (t, p)
+{
+    var k = 1 - t;
+
+    return 3 * k * k * t * p;
+}
+
+function P2 (t, p)
+{
+    return 3 * ( 1 - t ) * t * t * p;
+}
+
+function P3 (t, p)
+{
+    return t * t * t * p;
+}
+
+//  p0 = start point
+//  p1 = control point 1
+//  p2 = control point 2
+//  p3 = end point
+
+// https://medium.com/@adrian_cooney/bezier-interpolation-13b68563313a
+
+var CubicBezierInterpolation = function (t, p0, p1, p2, p3)
+{
+    return P0(t, p0) + P1(t, p1) + P2(t, p2) + P3(t, p3);
+};
+
+module.exports = CubicBezierInterpolation;

v3/src/math/interpolation/index.js

@@ -1,7 +1,10 @@
+//  Phaser.Math.Interpolation
+
 module.exports = {
 
     Bezier: require('./BezierInterpolation'),
     CatmullRom: require('./CatmullRomInterpolation'),
+    CubicBezier: require('./CubicBezierInterpolation'),
     Linear: require('./LinearInterpolation')
 
 };

v3/src/paths/curves/Curve.js

@@ -1,69 +1,42 @@
+//  Based on the three.js Curve classes created by [zz85](http://www.lab4games.net/zz85/blog)
+
 var Clamp = require('../../math/Clamp');
+var Vector2 = require('../../math/Vector2');
 var Vector3 = require('../../math/Vector3');
 var Matrix4 = require('../../math/Matrix4');
 var Class = require('../../utils/Class');
 
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * Extensible curve object
- *
- * Some common of Curve methods
- * .getPoint(t), getTangent(t)
- * .getPointAt(u), getTangentAt(u)
- * .getPoints(), .getSpacedPoints()
- * .getLength()
- * .updateArcLengths()
- *
- * This following classes subclasses THREE.Curve:
- *
- * -- 2d classes --
- * THREE.LineCurve
- * THREE.QuadraticBezierCurve
- * THREE.CubicBezierCurve
- * THREE.SplineCurve
- * THREE.ArcCurve
- * THREE.EllipseCurve
- *
- * -- 3d classes --
- * THREE.LineCurve3
- * THREE.QuadraticBezierCurve3
- * THREE.CubicBezierCurve3
- * THREE.SplineCurve3
- *
- * A series of curves can be represented as a THREE.CurvePath
- *
- **/
-
-/**************************************************************
- *  Abstract Curve base class
- **************************************************************/
+//  Local cache vars
+
+var tmpVec2A = new Vector2();
+var tmpVec2B = new Vector2();
+
+//  Our Base Curve which all other curves extend
 
 var Curve = new Class({
 
     initialize:
 
     function Curve ()
     {
+        this.arcLengthDivisions = 200;
     },
 
     // Get point at relative position in curve according to arc length
     // - u [0 .. 1]
 
-    getPointAt: function (u)
+    getPointAt: function (u, out)
     {
         var t = this.getUtoTmapping(u);
 
-        return this.getPoint(t);
+        return this.getPoint(t, out);
     },
 
     // Get sequence of points using getPoint( t )
 
     getPoints: function (divisions)
     {
-        if (!divisions)
-        {
-            divisions = 5;
-        }
+        if (divisions === undefined) { divisions = 5; }
 
         var points = [];
 
@@ -79,10 +52,7 @@ var Curve = new Class({
 
     getSpacedPoints: function (divisions)
     {
-        if (!divisions)
-        {
-            divisions = 5;
-        }
+        if (divisions === undefined) { divisions = 5; }
 
         var points = [];
 
@@ -107,10 +77,7 @@ var Curve = new Class({
 
     getLengths: function (divisions)
     {
-        if (!divisions)
-        {
-            divisions = (this.__arcLengthDivisions) ? (this.__arcLengthDivisions) : 200;
-        }
+        if (divisions === undefined) { divisions = this.arcLengthDivisions; }
 
         if (this.cacheArcLengths &&
             (this.cacheArcLengths.length === divisions + 1) &&
@@ -123,15 +90,15 @@ var Curve = new Class({
 
         var cache = [];
         var current;
-        var last = this.getPoint(0);
+        var last = this.getPoint(0, tmpVec2A);
         var sum = 0;
 
         cache.push(0);
 
         for (var p = 1; p <= divisions; p++)
         {
-            current = this.getPoint(p / divisions);
-            sum += current.distanceTo(last);
+            current = this.getPoint(p / divisions, tmpVec2B);
+            sum += current.distance(last);
             cache.push(sum);
             last = current;
         }
@@ -199,9 +166,7 @@ var Curve = new Class({
 
         if (arcLengths[i] === targetArcLength)
         {
-            var t = i / (il - 1);
-
-            return t;
+            return i / (il - 1);
         }
 
         // we could get finer grain at lengths, or use simple interpolation between two points
@@ -225,8 +190,10 @@ var Curve = new Class({
     // 2 points a small delta apart will be used to find its gradient
     // which seems to give a reasonable approximation
 
-    getTangent: function (t)
+    getTangent: function (t, out)
     {
+        if (out === undefined) { out = new Vector2(); }
+
         var delta = 0.0001;
         var t1 = t - delta;
         var t2 = t + delta;
@@ -243,19 +210,22 @@ var Curve = new Class({
             t2 = 1;
         }
 
-        var pt1 = this.getPoint(t1);
-        var pt2 = this.getPoint(t2);
+        // var pt1 = this.getPoint(t1);
+        // var pt2 = this.getPoint(t2);
+        // var vec = pt2.clone().sub(pt1);
+        // return vec.normalize();
 
-        var vec = pt2.clone().sub(pt1);
+        this.getPoint(t1, tmpVec2A);
+        this.getPoint(t2, out);
 
-        return vec.normalize();
+        return out.sub(tmpVec2A).normalize();
     },
 
-    getTangentAt: function (u)
+    getTangentAt: function (u, out)
     {
         var t = this.getUtoTmapping(u);
 
-        return this.getTangent(t);
+        return this.getTangent(t, out);
     },
 
     computeFrenetFrames: function (segments, closed)

v3/src/paths/curves/cubicbezier/CubicBezierCurve.js

@@ -0,0 +1,41 @@
+//  Based on the three.js Curve classes created by [zz85](http://www.lab4games.net/zz85/blog)
+
+var Class = require('../../../utils/Class');
+var Curve = require('../Curve');
+var Vector2 = require('../../../math/Vector2');
+var CubicBezier = require('../../../math/interpolation/CubicBezierInterpolation');
+
+//  Phaser.Paths.Curves.CubicBezier
+
+var CubicBezierCurve = new Class({
+
+    Extends: Curve,
+
+    initialize:
+
+    function CubicBezierCurve (v0, v1, v2, v3)
+    {
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+        this.v3 = v3;
+    },
+
+    getPoint: function (t, out)
+    {
+        if (out === undefined) { out = new Vector2(); }
+
+        var v0 = this.v0;
+        var v1 = this.v1;
+        var v2 = this.v2;
+        var v3 = this.v3;
+
+        return out.set(
+            CubicBezier(t, v0.x, v1.x, v2.x, v3.x),
+            CubicBezier(t, v0.y, v1.y, v2.y, v3.y)
+        );
+    }
+
+});
+
+module.exports = CubicBezierCurve;

v3/src/paths/curves/ellipse/EllipseCurve.js

@@ -0,0 +1,93 @@
+//  Based on the three.js Curve classes created by [zz85](http://www.lab4games.net/zz85/blog)
+
+var Curve = require('../Curve');
+var Class = require('../../../utils/Class');
+
+//  Phaser.Paths.Curves.Ellipse
+
+var EllipseCurve = new Class({
+
+    Extends: Curve,
+
+    initialize:
+
+    function EllipseCurve (aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation)
+    {
+        this.aX = aX;
+        this.aY = aY;
+
+        this.xRadius = xRadius;
+        this.yRadius = yRadius;
+
+        this.aStartAngle = aStartAngle;
+        this.aEndAngle = aEndAngle;
+
+        this.aClockwise = aClockwise;
+
+        this.aRotation = aRotation || 0;
+    },
+
+    getPoint: function (t)
+    {
+        var twoPi = Math.PI * 2;
+        var deltaAngle = this.aEndAngle - this.aStartAngle;
+        var samePoints = Math.abs( deltaAngle ) < Number.EPSILON;
+
+        // ensures that deltaAngle is 0 .. 2 PI
+        while (deltaAngle < 0)
+        {
+            deltaAngle += twoPi;
+        }
+
+        while (deltaAngle > twoPi)
+        {
+            deltaAngle -= twoPi;
+        }
+
+        if (deltaAngle < Number.EPSILON)
+        {
+            if (samePoints)
+            {
+                deltaAngle = 0;
+            }
+            else
+            {
+                deltaAngle = twoPi;
+            }
+        }
+
+        if (this.aClockwise === true && ! samePoints)
+        {
+            if (deltaAngle === twoPi)
+            {
+                deltaAngle = - twoPi;
+            }
+            else
+            {
+                deltaAngle = deltaAngle - twoPi;
+            }
+        }
+
+        var angle = this.aStartAngle + t * deltaAngle;
+        var x = this.aX + this.xRadius * Math.cos(angle);
+        var y = this.aY + this.yRadius * Math.sin(angle);
+
+        if (this.aRotation !== 0)
+        {
+            var cos = Math.cos(this.aRotation);
+            var sin = Math.sin(this.aRotation);
+
+            var tx = x - this.aX;
+            var ty = y - this.aY;
+
+            // Rotate the point about the center of the ellipse.
+            x = tx * cos - ty * sin + this.aX;
+            y = tx * sin + ty * cos + this.aY;
+        }
+
+        return new Vector2(x, y);
+    }
+
+});
+
+module.exports = EllipseCurve;

v3/src/paths/curves/index.js

@@ -0,0 +1,11 @@
+//  Phaser.Curves
+
+module.exports = {
+    
+    CubicBezier: require('./cubicbezier/CubicBezierCurve'),
+    Ellipse: require('./ellipse/EllipseCurve'),
+    Line: require('./line/LineCurve')
+
+};
+
+//     Hermite: require('./curves/hermite')