Added Star shape

src/gameobjects/index.js

@@ -44,6 +44,7 @@ var GameObjects = {
     IsoBox: require('./shape/isobox/IsoBox'),
     Polygon: require('./shape/polygon/Polygon'),
     Rectangle: require('./shape/rectangle/Rectangle'),
+    Star: require('./shape/star/Star'),
     Triangle: require('./shape/triangle/Triangle'),
 
     //  Game Object Factories
@@ -70,6 +71,7 @@ var GameObjects = {
         IsoBox: require('./shape/isobox/IsoBoxFactory'),
         Polygon: require('./shape/polygon/PolygonFactory'),
         Rectangle: require('./shape/rectangle/RectangleFactory'),
+        Star: require('./shape/star/StarFactory'),
         Triangle: require('./shape/triangle/TriangleFactory')
     },
 

src/gameobjects/shape/star/Star.js

@@ -0,0 +1,99 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2018 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var StarRender = require('./StarRender');
+var Class = require('../../../utils/Class');
+var Earcut = require('../../../geom/polygon/Earcut');
+var Shape = require('../Shape');
+
+/**
+ * @classdesc
+ *
+ * @class Star
+ * @extends Phaser.GameObjects.Shape
+ * @memberOf Phaser.GameObjects
+ * @constructor
+ * @since 3.13.0
+ *
+ * @param {Phaser.Scene} scene - The Scene to which this Game Object belongs. A Game Object can only belong to one Scene at a time.
+ * @param {number} x - The horizontal position of this Game Object in the world.
+ * @param {number} y - The vertical position of this Game Object in the world.
+ */
+var Star = new Class({
+
+    Extends: Shape,
+
+    Mixins: [
+        StarRender
+    ],
+
+    initialize:
+
+    function Star (scene, x, y, points, innerRadius, outerRadius, fillColor, fillAlpha)
+    {
+        if (x === undefined) { x = 0; }
+        if (y === undefined) { y = 0; }
+        if (points === undefined) { points = 5; }
+        if (innerRadius === undefined) { innerRadius = 32; }
+        if (outerRadius === undefined) { outerRadius = 64; }
+
+        Shape.call(this, scene, 'Star', null);
+
+        this.points = points;
+        this.innerRadius = innerRadius;
+        this.outerRadius = outerRadius;
+
+        this.setPosition(x, y);
+        this.setSize(outerRadius * 2, outerRadius * 2);
+
+        if (fillColor !== undefined)
+        {
+            this.setFillStyle(fillColor, fillAlpha);
+        }
+
+        this.updateDisplayOrigin();
+        this.updateData();
+    },
+
+    updateData: function ()
+    {
+        var path = [];
+
+        var points = this.points;
+        var innerRadius = this.innerRadius;
+        var outerRadius = this.outerRadius;
+
+        var rot = Math.PI / 2 * 3;
+        var step = Math.PI / points;
+
+        //  So origin 0.5 = the center of the star
+        var x = outerRadius;
+        var y = outerRadius;
+    
+        path.push(x, y + -outerRadius);
+
+        for (var i = 0; i < points; i++)
+        {
+            path.push(x + Math.cos(rot) * outerRadius, y + Math.sin(rot) * outerRadius);
+
+            rot += step;
+
+            path.push(x + Math.cos(rot) * innerRadius, y + Math.sin(rot) * innerRadius);
+    
+            rot += step;
+        }
+
+        path.push(x, y + -outerRadius);
+
+        this.pathIndexes = Earcut(path);
+        this.pathData = path;
+
+        return this;
+    }
+
+});
+
+module.exports = Star;

src/gameobjects/shape/star/StarCanvasRenderer.js

@@ -0,0 +1,26 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2018 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+/**
+ * Renders this Game Object with the Canvas Renderer to the given Camera.
+ * The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
+ * This method should not be called directly. It is a utility function of the Render module.
+ *
+ * @method Phaser.GameObjects.Star#renderCanvas
+ * @since 3.13.0
+ * @private
+ *
+ * @param {Phaser.Renderer.Canvas.CanvasRenderer} renderer - A reference to the current active Canvas renderer.
+ * @param {Phaser.GameObjects.Star} src - The Game Object being rendered in this call.
+ * @param {number} interpolationPercentage - Reserved for future use and custom pipelines.
+ * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
+ * @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
+ */
+var StarCanvasRenderer = function (renderer, src, interpolationPercentage, camera, parentMatrix)
+{
+};
+
+module.exports = StarCanvasRenderer;

src/gameobjects/shape/star/StarFactory.js

@@ -0,0 +1,31 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2018 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var Star = require('./Star');
+var GameObjectFactory = require('../../GameObjectFactory');
+
+/**
+ * Creates a new Star Shape Game Object and adds it to the Scene.
+ *
+ * Note: This method will only be available if the Star Game Object has been built into Phaser.
+ *
+ * @method Phaser.GameObjects.GameObjectFactory#star
+ * @since 3.13.0
+ *
+ * @param {number} [x=0] - The horizontal position of this Game Object in the world.
+ * @param {number} [y=0] - The vertical position of this Game Object in the world.
+ * @param {number} [points=5] - The number of points on the star.
+ * @param {number} [innerRadius=32] - The inner radius of the star.
+ * @param {number} [outerRadius=64] - The outer radius of the star.
+ * @param {number} [fillColor] - The color the star will be filled with, i.e. 0xff0000 for red.
+ * @param {number} [fillAlpha] - The alpha the star will be filled with. You can also set the alpha of the overall Shape using its `alpha` property.
+ *
+ * @return {Phaser.GameObjects.Star} The Game Object that was created.
+ */
+GameObjectFactory.register('star', function (x, y, points, innerRadius, outerRadius, fillColor, fillAlpha)
+{
+    return this.displayList.add(new Star(this.scene, x, y, points, innerRadius, outerRadius, fillColor, fillAlpha));
+});

src/gameobjects/shape/star/StarRender.js

@@ -0,0 +1,25 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2018 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var renderWebGL = require('../../../utils/NOOP');
+var renderCanvas = require('../../../utils/NOOP');
+
+if (typeof WEBGL_RENDERER)
+{
+    renderWebGL = require('./StarWebGLRenderer');
+}
+
+if (typeof CANVAS_RENDERER)
+{
+    renderCanvas = require('./StarCanvasRenderer');
+}
+
+module.exports = {
+
+    renderWebGL: renderWebGL,
+    renderCanvas: renderCanvas
+
+};

src/gameobjects/shape/star/StarWebGLRenderer.js

@@ -0,0 +1,135 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2018 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var Utils = require('../../../renderer/webgl/Utils');
+
+/**
+ * Renders this Game Object with the WebGL Renderer to the given Camera.
+ * The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
+ * This method should not be called directly. It is a utility function of the Render module.
+ *
+ * @method Phaser.GameObjects.Star#renderWebGL
+ * @since 3.13.0
+ * @private
+ *
+ * @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
+ * @param {Phaser.GameObjects.Star} src - The Game Object being rendered in this call.
+ * @param {number} interpolationPercentage - Reserved for future use and custom pipelines.
+ * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
+ * @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
+ */
+var StarWebGLRenderer = function (renderer, src, interpolationPercentage, camera, parentMatrix)
+{
+    var pipeline = this.pipeline;
+
+    var camMatrix = pipeline._tempMatrix1;
+    var shapeMatrix = pipeline._tempMatrix2;
+    var calcMatrix = pipeline._tempMatrix3;
+
+    renderer.setPipeline(pipeline);
+
+    shapeMatrix.applyITRS(src.x, src.y, src.rotation, src.scaleX, src.scaleY);
+
+    camMatrix.copyFrom(camera.matrix);
+
+    if (parentMatrix)
+    {
+        //  Multiply the camera by the parent matrix
+        camMatrix.multiplyWithOffset(parentMatrix, -camera.scrollX * src.scrollFactorX, -camera.scrollY * src.scrollFactorY);
+
+        //  Undo the camera scroll
+        shapeMatrix.e = src.x;
+        shapeMatrix.f = src.y;
+    }
+    else
+    {
+        shapeMatrix.e -= camera.scrollX * src.scrollFactorX;
+        shapeMatrix.f -= camera.scrollY * src.scrollFactorY;
+    }
+
+    camMatrix.multiply(shapeMatrix, calcMatrix);
+
+    var i;
+    var dx = src._displayOriginX;
+    var dy = src._displayOriginY;
+
+    var alpha = camera.alpha * src.alpha;
+
+    var path = src.pathData;
+
+    if (src.isFilled)
+    {
+        var fillTintColor = Utils.getTintAppendFloatAlphaAndSwap(src.fillColor, src.fillAlpha * alpha);
+
+        var pathIndexes = src.pathIndexes;
+    
+        for (i = 0; i < pathIndexes.length; i += 3)
+        {
+            var p0 = pathIndexes[i] * 2;
+            var p1 = pathIndexes[i + 1] * 2;
+            var p2 = pathIndexes[i + 2] * 2;
+    
+            var x0 = path[p0 + 0] - dx;
+            var y0 = path[p0 + 1] - dy;
+            var x1 = path[p1 + 0] - dx;
+            var y1 = path[p1 + 1] - dy;
+            var x2 = path[p2 + 0] - dx;
+            var y2 = path[p2 + 1] - dy;
+    
+            var tx0 = calcMatrix.getX(x0, y0);
+            var ty0 = calcMatrix.getY(x0, y0);
+    
+            var tx1 = calcMatrix.getX(x1, y1);
+            var ty1 = calcMatrix.getY(x1, y1);
+    
+            var tx2 = calcMatrix.getX(x2, y2);
+            var ty2 = calcMatrix.getY(x2, y2);
+        
+            pipeline.batchTri(tx0, ty0, tx1, ty1, tx2, ty2, 0, 0, 1, 1, fillTintColor, fillTintColor, fillTintColor, pipeline.tintEffect);
+        }
+    }
+
+    if (src.isStroked)
+    {
+        var strokeTint = pipeline.strokeTint;
+        var strokeTintColor = Utils.getTintAppendFloatAlphaAndSwap(src.strokeColor, src.strokeAlpha * alpha);
+    
+        strokeTint.TL = strokeTintColor;
+        strokeTint.TR = strokeTintColor;
+        strokeTint.BL = strokeTintColor;
+        strokeTint.BR = strokeTintColor;
+
+        var pathLength = path.length - 1;
+        var lineWidth = src.lineWidth;
+        var halfLineWidth = lineWidth / 2;
+
+        var px1 = path[0] - dx;
+        var py1 = path[1] - dy;
+
+        for (i = 2; i < pathLength; i += 2)
+        {
+            var px2 = path[i] - dx;
+            var py2 = path[i + 1] - dy;
+
+            pipeline.batchLine(
+                px1,
+                py1,
+                px2,
+                py2,
+                halfLineWidth,
+                halfLineWidth,
+                lineWidth,
+                i - 2,
+                (i === pathLength - 1)
+            );
+
+            px1 = px2;
+            py1 = py2;
+        }
+    }
+};
+
+module.exports = StarWebGLRenderer;