phaser4-rex-plugins
Version:
1,775 lines (1,432 loc) • 102 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.rexcustomprogressplugin = factory());
})(this, (function () { 'use strict';
const GetCalcMatrix = Phaser.GameObjects.GetCalcMatrix;
var WebGLRenderer = function (renderer, src, drawingContext, parentMatrix) {
src.updateData();
var camera = drawingContext.camera;
camera.addToRenderList(src);
var calcMatrix = GetCalcMatrix(src, camera, parentMatrix, !drawingContext.useCanvas).calc;
var dx = src._displayOriginX;
var dy = src._displayOriginY;
var alpha = src.alpha;
var submitter = src.customRenderNodes.Submitter || src.defaultRenderNodes.Submitter;
var shapes = src.geom,
shape;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
shape = shapes[i];
if (shape.visible) {
shape.webglRender(drawingContext, submitter, calcMatrix, src, alpha, dx, dy);
}
}
};
const SetTransform = Phaser.Renderer.Canvas.SetTransform;
var CanvasRenderer = function (renderer, src, camera, parentMatrix) {
src.updateData();
camera.addToRenderList(src);
var ctx = renderer.currentContext;
if (SetTransform(renderer, ctx, src, camera, parentMatrix)) {
var dx = src._displayOriginX;
var dy = src._displayOriginY;
var shapes = src.geom,
shape;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
shape = shapes[i];
if (shape.visible) {
shape.canvasRender(ctx, dx, dy);
}
}
// Restore the context saved in SetTransform
ctx.restore();
}
};
var Render = {
renderWebGL: WebGLRenderer,
renderCanvas: CanvasRenderer
};
var Clear = function (obj) {
if ((typeof (obj) !== 'object') || (obj === null)) {
return obj;
}
if (Array.isArray(obj)) {
obj.length = 0;
} else {
for (var key in obj) {
delete obj[key];
}
}
return obj;
};
const Shape = Phaser.GameObjects.Shape;
const RemoveItem = Phaser.Utils.Array.Remove;
class BaseShapes extends Shape {
constructor(scene, x, y, width, height) {
if (x === undefined) {
x = 0;
}
if (y === undefined) {
y = 0;
}
if (width === undefined) {
width = 2;
}
if (height === undefined) {
height = width;
}
super(scene, 'rexShapes', []);
this._width = -1;
this._height = -1;
this.dirty = true;
this.isSizeChanged = true;
this.shapes = {};
this.setPosition(x, y);
this.setSize(width, height);
this.updateDisplayOrigin();
}
get width() {
return this._width;
}
set width(value) {
this.setSize(value, this._height);
}
get height() {
return this._height;
}
set height(value) {
this.setSize(this._width, value);
}
setDirty(value) {
if (value === undefined) {
value = true;
}
this.dirty = value;
return this;
}
setSize(width, height) {
this.isSizeChanged = this.isSizeChanged || (this._width !== width) || (this._height !== height);
this.dirty = this.dirty || this.isSizeChanged;
this._width = width;
this._height = height;
this.updateDisplayOrigin();
var input = this.input;
if (input && !input.customHitArea) {
input.hitArea.width = width;
input.hitArea.height = height;
}
return this;
}
resize(width, height) {
this.setSize(width, height);
return this;
}
get fillColor() {
return this._fillColor;
}
set fillColor(value) {
this.setFillStyle(value, this._fillAlpha);
}
get fillAlpha() {
return this._fillAlpha;
}
set fillAlpha(value) {
this.setFillStyle(this._fillColor, value);
}
setFillStyle(color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.fillColor !== color) ||
(this.fillAlpha !== alpha);
this._fillColor = color;
this._fillAlpha = alpha;
return this;
}
get lineWidth() {
return this._lineWidth;
}
set lineWidth(value) {
this.setStrokeStyle(value, this._strokeColor, this._strokeAlpha);
}
get strokeColor() {
return this._strokeColor;
}
set strokeColor(value) {
this.setStrokeStyle(this._lineWidth, value, this._strokeAlpha);
}
get strokeAlpha() {
return this._strokeAlpha;
}
set strokeAlpha(value) {
this.setStrokeStyle(this._lineWidth, this._strokeColor, value);
}
setStrokeStyle(lineWidth, color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.lineWidth !== lineWidth) ||
(this.strokeColor !== color) ||
(this.strokeAlpha !== alpha);
this._lineWidth = lineWidth;
this._strokeColor = color;
this._strokeAlpha = alpha;
return this;
}
updateShapes() {
}
updateData() {
if (!this.dirty) {
return this;
}
this.updateShapes();
var shapes = this.geom;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
var shape = shapes[i];
if (shape.dirty) {
shape.updateData();
}
}
this.isSizeChanged = false;
this.dirty = false;
return this;
}
clear() {
this.geom.length = 0;
Clear(this.shapes);
this.dirty = true;
return this;
}
getShape(name) {
return this.shapes[name];
}
getShapes() {
return this.geom;
}
addShape(shape) {
this.geom.push(shape);
var name = shape.name;
if (name) {
this.shapes[name] = shape;
}
this.dirty = true;
return this;
}
deleteShape(name) {
var shape = this.getShape(name);
if (shape) {
delete this.shapes[name];
RemoveItem(this.geom, shape);
}
return this;
}
}
Object.assign(
BaseShapes.prototype,
Render
);
var FillStyle = function (color, alpha) {
if (color == null) {
this.isFilled = false;
} else {
if (alpha === undefined) {
alpha = 1;
}
this.isFilled = true;
this.fillColor = color;
this.fillAlpha = alpha;
}
return this;
};
var LineStyle = function (lineWidth, color, alpha) {
if ((lineWidth == null) || (color == null)) {
this.isStroked = false;
} else {
if (alpha === undefined) {
alpha = 1;
}
this.isStroked = true;
this.lineWidth = lineWidth;
this.strokeColor = color;
this.strokeAlpha = alpha;
}
return this;
};
var StyleMethods = {
fillStyle: FillStyle,
lineStyle: LineStyle
};
var GetValue$b = function (source, key, defaultValue) {
if (!source || typeof source === 'number') {
return defaultValue;
}
if (typeof (key) === 'string') {
if (source.hasOwnProperty(key)) {
return source[key];
}
if (key.indexOf('.') !== -1) {
key = key.split('.');
} else {
return defaultValue;
}
}
var keys = key;
var parent = source;
var value = defaultValue;
// Use for loop here so we can break early
for (var i = 0; i < keys.length; i++) {
key = keys[i];
if (parent.hasOwnProperty(key)) {
// Yes it has a key property, let's carry on down
value = parent[key];
parent = value;
}
else {
// Can't go any further, so reset to default
value = defaultValue;
break;
}
}
return value;
};
var DataMethods = {
enableData() {
if (this.data === undefined) {
this.data = {};
}
return this;
},
setData(key, value) {
this.enableData();
if (arguments.length === 1) {
var data = key;
for (key in data) {
this.data[key] = data[key];
}
} else {
this.data[key] = value;
}
return this;
},
getData(key, defaultValue) {
this.enableData();
return (key === undefined) ? this.data : GetValue$b(this.data, key, defaultValue);
},
incData(key, inc, defaultValue) {
if (defaultValue === undefined) {
defaultValue = 0;
}
this.enableData();
this.setData(key, this.getData(key, defaultValue) + inc);
return this;
},
mulData(key, mul, defaultValue) {
if (defaultValue === undefined) {
defaultValue = 0;
}
this.enableData();
this.setData(key, this.getData(key, defaultValue) * mul);
return this;
},
clearData() {
if (this.data) {
Clear(this.data);
}
return this;
},
};
class BaseGeom {
constructor() {
this.name = undefined;
this.dirty = true;
this.visible = true;
this.data = undefined;
this.isFilled = false;
this.fillColor = undefined;
this.fillAlpha = 1;
this.isStroked = false;
this.lineWidth = 1;
this.strokeColor = undefined;
this.strokeAlpha = 1;
}
setName(name) {
this.name = name;
return this;
}
setVisible(visible) {
if (visible === undefined) {
visible = true;
}
this.visible = visible;
return this;
}
reset() {
this
.setVisible()
.fillStyle()
.lineStyle();
return this;
}
webglRender(drawingContext, submitter, gameObject, calcMatrix, alpha, dx, dy) {
}
canvasRender(ctx, dx, dy) {
}
updateData() {
this.dirty = false;
}
}
Object.assign(
BaseGeom.prototype,
StyleMethods,
DataMethods
);
/*
shapeData: {
fillColor,
fillAlpha,
pathData,
pathIndexes // Earcut(pathData)
}
*/
var Utils$3 = Phaser.Renderer.WebGL.Utils;
var FillPathWebGL = function (drawingContext, submitter, calcMatrix, gameObject, shapeData, alpha, dx, dy) {
// This is very similar to the FillPath RenderNode, but it already
// has access to the Earcut indexes, so it doesn't need to calculate them.
var fillTintColor = Utils$3.getTintAppendFloatAlpha(shapeData.fillColor, shapeData.fillAlpha * alpha);
var path = shapeData.pathData;
var pathIndexes = shapeData.pathIndexes;
var length = path.length;
var pathIndex, pointX, pointY, x, y;
var vertices = Array(length * 2);
var colors = Array(length);
var verticesIndex = 0;
var colorsIndex = 0;
for (pathIndex = 0; pathIndex < length; pathIndex += 2) {
pointX = path[pathIndex] - dx;
pointY = path[pathIndex + 1] - dy;
// Transform the point.
x = calcMatrix.getX(pointX, pointY);
y = calcMatrix.getY(pointX, pointY);
vertices[verticesIndex++] = x;
vertices[verticesIndex++] = y;
colors[colorsIndex++] = fillTintColor;
}
submitter.batch(
drawingContext,
pathIndexes,
vertices,
colors
);
};
/*
shapeData: {
strokeColor,
strokeAlpha,
pathData,
lineWidth,
closePath
}
*/
var Utils$2 = Phaser.Renderer.WebGL.Utils;
var StrokePathWebGL = function (drawingContext, submitter, matrix, gameObject, shapeData, alpha, dx, dy) {
var strokeTintColor = Utils$2.getTintAppendFloatAlpha(shapeData.strokeColor, shapeData.strokeAlpha * alpha);
var path = shapeData.pathData;
var pathLength = path.length - 1;
var lineWidth = shapeData.lineWidth;
var openPath = !shapeData.closePath;
var strokePath = gameObject.customRenderNodes.StrokePath || gameObject.defaultRenderNodes.StrokePath;
var pointPath = [];
// Don't add the last point to open paths.
if (openPath) {
pathLength -= 2;
}
for (var i = 0; i < pathLength; i += 2) {
var x = path[i] - dx;
var y = path[i + 1] - dy;
if (i > 0) {
if (x === path[i - 2] && y === path[i - 1]) {
// Duplicate point, skip it
continue;
}
}
pointPath.push({
x: x,
y: y,
width: lineWidth
});
}
strokePath.run(
drawingContext,
submitter,
pointPath,
lineWidth,
openPath,
matrix,
strokeTintColor, strokeTintColor, strokeTintColor, strokeTintColor
);
};
var FillStyleCanvas = function (ctx, src, altColor, altAlpha)
{
var fillColor = (altColor) ? altColor : src.fillColor;
var fillAlpha = (altAlpha) ? altAlpha : src.fillAlpha;
var red = ((fillColor & 0xFF0000) >>> 16);
var green = ((fillColor & 0xFF00) >>> 8);
var blue = (fillColor & 0xFF);
ctx.fillStyle = 'rgba(' + red + ',' + green + ',' + blue + ',' + fillAlpha + ')';
};
var LineStyleCanvas = function (ctx, src, altColor, altAlpha)
{
var strokeColor = (altColor) ? altColor : src.strokeColor;
var strokeAlpha = (altAlpha) ? altAlpha : src.strokeAlpha;
var red = ((strokeColor & 0xFF0000) >>> 16);
var green = ((strokeColor & 0xFF00) >>> 8);
var blue = (strokeColor & 0xFF);
ctx.strokeStyle = 'rgba(' + red + ',' + green + ',' + blue + ',' + strokeAlpha + ')';
ctx.lineWidth = src.lineWidth;
};
const Earcut = Phaser.Geom.Polygon.Earcut;
class PathBase extends BaseGeom {
constructor() {
super();
this.pathData = [];
this.pathIndexes = [];
this.closePath = false;
}
updateData() {
this.pathIndexes = Earcut(this.pathData);
super.updateData();
return this;
}
webglRender(drawingContext, submitter, calcMatrix, gameObject, alpha, dx, dy) {
if (this.isFilled) {
FillPathWebGL(drawingContext, submitter, calcMatrix, gameObject, this, alpha, dx, dy);
}
if (this.isStroked) {
StrokePathWebGL(drawingContext, submitter, calcMatrix, gameObject, this, alpha, dx, dy);
}
}
canvasRender(ctx, dx, dy) {
var path = this.pathData;
var pathLength = path.length - 1;
var px1 = path[0] - dx;
var py1 = path[1] - dy;
ctx.beginPath();
ctx.moveTo(px1, py1);
if (!this.closePath) {
pathLength -= 2;
}
for (var i = 2; i < pathLength; i += 2) {
var px2 = path[i] - dx;
var py2 = path[i + 1] - dy;
ctx.lineTo(px2, py2);
}
if (this.closePath) {
ctx.closePath();
}
if (this.isFilled) {
FillStyleCanvas(ctx, this);
ctx.fill();
}
if (this.isStroked) {
LineStyleCanvas(ctx, this);
ctx.stroke();
}
}
}
var LineTo = function (x, y, pathData) {
var cnt = pathData.length;
if (cnt >= 2) {
var lastX = pathData[cnt - 2];
var lastY = pathData[cnt - 1];
if ((x === lastX) && (y === lastY)) {
return pathData;
}
}
pathData.push(x, y);
return pathData;
};
const DegToRad$2 = Phaser.Math.DegToRad;
var ArcTo = function (centerX, centerY, radiusX, radiusY, startAngle, endAngle, antiClockWise, iteration, pathData) {
// startAngle, endAngle: 0 ~ 360
if (antiClockWise && (endAngle > startAngle)) {
endAngle -= 360;
} else if (!antiClockWise && (endAngle < startAngle)) {
endAngle += 360;
}
var deltaAngle = endAngle - startAngle;
var step = DegToRad$2(deltaAngle) / iteration;
startAngle = DegToRad$2(startAngle);
for (var i = 0; i <= iteration; i++) {
var angle = startAngle + (step * i);
var x = centerX + (radiusX * Math.cos(angle));
var y = centerY + (radiusY * Math.sin(angle));
LineTo(x, y, pathData);
}
return pathData;
};
const DegToRad$1 = Phaser.Math.DegToRad;
class Arc extends PathBase {
constructor(x, y, radiusX, radiusY, startAngle, endAngle, anticlockwise, pie) {
if (x === undefined) { x = 0; }
if (y === undefined) { y = 0; }
if (radiusX === undefined) { radiusX = 0; }
if (radiusY === undefined) { radiusY = 0; }
if (startAngle === undefined) { startAngle = 0; }
if (endAngle === undefined) { endAngle = 360; }
if (anticlockwise === undefined) { anticlockwise = false; }
if (pie === undefined) { pie = false; }
super();
this.setCenterPosition(x, y);
this.setRadius(radiusX, radiusY);
this.setAngle(startAngle, endAngle, anticlockwise);
this.setPie(pie);
this.setIterations(32);
}
get x() {
return this._x;
}
set x(value) {
this.dirty = this.dirty || (this._x !== value);
this._x = value;
}
get y() {
return this._y;
}
set y(value) {
this.dirty = this.dirty || (this._y !== value);
this._y = value;
}
setCenterPosition(x, y) {
if (y === undefined) {
y = x;
}
this.x = x;
this.y = y;
return this;
}
get radiusX() {
return this._radiusX;
}
set radiusX(value) {
this.dirty = this.dirty || (this._radiusX !== value);
this._radiusX = value;
}
get radiusY() {
return this._radiusY;
}
set radiusY(value) {
this.dirty = this.dirty || (this._radiusY !== value);
this._radiusY = value;
}
setRadius(radiusX, radiusY) {
if (radiusY === undefined) {
radiusY = radiusX;
}
this.radiusX = radiusX;
this.radiusY = radiusY;
return this;
}
get startAngle() {
return this._startAngle;
}
set startAngle(value) {
this.dirty = this.dirty || (this._startAngle !== value);
this._startAngle = value;
}
get endAngle() {
return this._endAngle;
}
set endAngle(value) {
this.dirty = this.dirty || (this._endAngle !== value);
this._endAngle = value;
}
get anticlockwise() {
return this._anticlockwise;
}
set anticlockwise(value) {
this.dirty = this.dirty || (this._anticlockwise !== value);
this._anticlockwise = value;
}
setAngle(startAngle, endAngle, anticlockwise) {
// startAngle, endAngle in degrees
if (anticlockwise === undefined) {
anticlockwise = false;
}
this.startAngle = startAngle;
this.endAngle = endAngle;
this.anticlockwise = anticlockwise;
return this;
}
get pie() {
return this._pie;
}
set pie(value) {
this.dirty = this.dirty || (this._pie !== value);
this._pie = value;
}
setPie(pie) {
if (pie === undefined) {
pie = true;
}
this.pie = pie;
return this;
}
get iterations() {
return this._iterations;
}
set iterations(value) {
this.dirty = this.dirty || (this._iterations !== value);
this._iterations = value;
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
updateData() {
this.pathData.length = 0;
if (this.pie) {
this.pathData.push(this.x, this.y);
}
ArcTo(
this.x, this.y,
this.radiusX, this.radiusY,
this.startAngle, this.endAngle, this.anticlockwise,
this.iterations,
this.pathData
);
if (this.pie) {
this.pathData.push(this.x, this.y);
}
// Close
this.pathData.push(this.pathData[0], this.pathData[1]);
super.updateData();
return this;
}
canvasRender(ctx, dx, dy) {
ctx.beginPath();
var x = this.x - dx,
y = this.y - dy,
startAngle = DegToRad$1(this.startAngle),
endAngle = DegToRad$1(this.endAngle);
if (this.pie) {
ctx.moveTo(x, y);
ctx.lineTo(
x + Math.cos(startAngle) * this.radiusX,
y + Math.sin(startAngle) * this.radiusY
);
}
ctx.ellipse(
x, y,
this.radiusX, this.radiusY,
0,
startAngle, endAngle, this.anticlockwise
);
if (this.pie) {
ctx.lineTo(x, y);
}
if (this.isFilled) {
FillStyleCanvas(ctx, this);
ctx.fill();
}
if (this.isStroked) {
LineStyleCanvas(ctx, this);
ctx.stroke();
}
}
}
class Circle extends Arc {
constructor(x, y, radius) {
super(x, y, radius, radius, 0, 360);
}
}
class Curve extends PathBase {
constructor(curve) {
super();
this.setCurve(curve);
this.setIterations(32);
}
get curve() {
return this._curve;
}
set curve(value) {
this.dirty = this.dirty || (this._curve !== value);
this._curve = value;
}
setCurve(curve) {
this.curve = curve;
return this;
}
get iterations() {
return this._iterations;
}
set iterations(value) {
this.dirty = this.dirty || (this._iterations !== value);
this._iterations = value;
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
updateData() {
this.pathData.length = 0;
var points = this.curve.getPoints(this.iterations);
for (var i = 0, cnt = points.length; i < cnt; i++) {
this.pathData.push(points[i].x, points[i].y);
}
this.pathData.push(points[0].x, points[0].y);
super.updateData();
return this;
}
}
class Ellipse extends Arc {
constructor(x, y, radiusX, radiusY) {
super(x, y, radiusX, radiusY, 0, 360);
}
}
class Line extends PathBase {
constructor(x0, y0, x1, y1) {
if (x0 === undefined) { x0 = 0; }
if (y0 === undefined) { y0 = 0; }
if (x1 === undefined) { x1 = 0; }
if (y1 === undefined) { y1 = 0; }
super();
this.setP0(x0, y0);
this.setP1(x1, y1);
}
get x0() {
return this._x0;
}
set x0(value) {
this.dirty = this.dirty || (this._x0 !== value);
this._x0 = value;
}
get y0() {
return this._y0;
}
set y0(value) {
this.dirty = this.dirty || (this._y0 !== value);
this._y0 = value;
}
setP0(x, y) {
this.x0 = x;
this.y0 = y;
return this;
}
get x1() {
return this._x1;
}
set x1(value) {
this.dirty = this.dirty || (this._x1 !== value);
this._x1 = value;
}
get y1() {
return this._y1;
}
set y1(value) {
this.dirty = this.dirty || (this._y1 !== value);
this._y1 = value;
}
setP1(x, y) {
this.x1 = x;
this.y1 = y;
return this;
}
updateData() {
this.pathData.length = 0;
this.pathData.push(this.x0, this.y0);
this.pathData.push(this.x1, this.y1);
this.pathData.push(this.x0, this.y0);
super.updateData();
return this;
}
}
var StartAt = function (x, y, pathData) {
pathData.length = 0;
if (x != null) {
pathData.push(x, y);
}
return pathData;
};
//import QuadraticBezierInterpolation from '../../utils/math/interpolation/QuadraticBezierInterpolation.js';
const QuadraticBezierInterpolation = Phaser.Math.Interpolation.QuadraticBezier;
var QuadraticBezierTo = function (cx, cy, x, y, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
QuadraticBezierInterpolation(t, p0x, cx, x),
QuadraticBezierInterpolation(t, p0y, cy, y)
);
}
return pathData;
};
// import CubicBezierInterpolation from '../../utils/math/interpolation/CubicBezierInterpolation.js';
const CubicBezierInterpolation = Phaser.Math.Interpolation.CubicBezier;
var CubicBezierCurveTo = function (cx0, cy0, cx1, cy1, x, y, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
CubicBezierInterpolation(t, p0x, cx0, cx1, x),
CubicBezierInterpolation(t, p0y, cy0, cy1, y)
);
}
return pathData;
};
//import CatmullRomInterpolation from '../../utils/math/interpolation/CatmullRomInterpolation.js';
const CatmullRomInterpolation = Phaser.Math.Interpolation.CatmullRom;
var CatmullRomTo = function (points, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
var xList = [p0x];
var yList = [p0y];
for (var i = 0, cnt = points.length; i < cnt; i += 2) {
xList.push(points[i]);
yList.push(points[i + 1]);
}
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
CatmullRomInterpolation(xList, t),
CatmullRomInterpolation(yList, t)
);
}
return pathData;
};
var DuplicateLast = function (pathData) {
var len = pathData.length;
if (len < 2) {
return pathData;
}
var lastX = pathData[len - 2];
var lastY = pathData[len - 1];
pathData.push(lastX);
pathData.push(lastY);
return pathData;
};
var AddPathMethods = {
clear() {
this.start();
return this;
},
start() {
this.startAt();
return this;
},
startAt(x, y) {
this.restorePathData();
this.accumulationLengths = undefined;
StartAt(x, y, this.pathData);
this.firstPointX = x;
this.firstPointY = y;
this.lastPointX = x;
this.lastPointY = y;
return this;
},
lineTo(x, y, relative) {
if (relative === undefined) {
relative = false;
}
if (relative) {
x += this.lastPointX;
y += this.lastPointY;
}
LineTo(x, y, this.pathData);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
verticalLineTo(x, relative) {
this.lineTo(x, this.lastPointY, relative);
return this;
},
horizontalLineTo(y, relative) {
this.lineTo(this.lastPointX, y, relative);
return this;
},
ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise) {
if (anticlockwise === undefined) {
anticlockwise = false;
}
ArcTo(
centerX, centerY,
radiusX, radiusY,
startAngle, endAngle, anticlockwise,
this.iterations,
this.pathData
);
this.lastPointX = this.pathData[this.pathData.length - 2];
this.lastPointY = this.pathData[this.pathData.length - 1];
return this;
},
arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise) {
this.ellipticalArc(centerX, centerY, radius, radius, startAngle, endAngle, anticlockwise);
return this;
},
quadraticBezierTo(cx, cy, x, y) {
QuadraticBezierTo(
cx, cy, x, y,
this.iterations,
this.pathData
);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
cubicBezierTo(cx0, cy0, cx1, cy1, x, y) {
CubicBezierCurveTo(
cx0, cy0, cx1, cy1, x, y,
this.iterations,
this.pathData
);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
catmullRomTo(...points) {
CatmullRomTo(
points,
this.iterations,
this.pathData
);
this.lastPointX = points[points.length-2];
this.lastPointY = points[points.length-1];
return this;
},
close() {
// Line to first point
var startX = this.pathData[0],
startY = this.pathData[1];
if ((startX !== this.lastPointX) || (startY !== this.lastPointY)) {
this.lineTo(startX, startY);
}
this.closePath = true;
return this;
},
end() {
DuplicateLast(this.pathData);
return this;
},
};
//import PointRotateAround from '../../utils/math/RotateAround.js';
const PointRotateAround = Phaser.Math.RotateAround;
var RotateAround = function (centerX, centerY, angle, pathData) {
var point = { x: 0, y: 0 };
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
point.x = pathData[i];
point.y = pathData[i + 1];
PointRotateAround(point, centerX, centerY, angle);
pathData[i] = point.x;
pathData[i + 1] = point.y;
}
return pathData;
};
var Scale = function (centerX, centerY, scaleX, scaleY, pathData) {
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
var x = pathData[i] - centerX;
var y = pathData[i + 1] - centerY;
x *= scaleX;
y *= scaleY;
pathData[i] = x + centerX;
pathData[i + 1] = y + centerY;
}
return pathData;
};
var Offset = function (x, y, pathData) {
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
pathData[i] += x;
pathData[i + 1] += y;
}
return pathData;
};
const DegToRad = Phaser.Math.DegToRad;
Phaser.Math.RotateAround;
var TransformPointsMethods = {
rotateAround(centerX, centerY, angle) {
if (this.pathData.length === 0) {
return this;
}
angle = DegToRad(angle);
RotateAround(centerX, centerY, angle, this.pathData);
var pathDataCnt = this.pathData.length;
this.lastPointX = this.pathData[pathDataCnt - 2];
this.lastPointY = this.pathData[pathDataCnt - 1];
return this;
},
scale(centerX, centerY, scaleX, scaleY) {
if (this.pathData.length === 0) {
return this;
}
Scale(centerX, centerY, scaleX, scaleY, this.pathData);
this.lastPointX = this.pathData[pathDataCnt - 2];
this.lastPointY = this.pathData[pathDataCnt - 1];
return this;
},
offset(x, y) {
Offset(x, y, this.pathData);
return this;
}
};
var Copy = function (dest, src, startIdx, endIdx) {
if (startIdx === undefined) {
startIdx = 0;
} if (endIdx === undefined) {
endIdx = src.length;
}
dest.length = endIdx - startIdx;
for (var i = 0, len = dest.length; i < len; i++) {
dest[i] = src[i + startIdx];
}
return dest;
};
var SavePathDataMethods = {
savePathData() {
if (this.pathDataSaved) {
return this;
}
this.pathDataSave = [...this.pathData];
this.pathData.length = 0;
this.pathDataSaved = true;
return this;
},
restorePathData() {
if (!this.pathDataSaved) {
return this;
}
Copy(this.pathData, this.pathDataSave);
this.pathDataSave = undefined;
this.pathDataSaved = false;
return this;
},
};
const DistanceBetween = Phaser.Math.Distance.Between;
const Wrap = Phaser.Math.Wrap;
const Linear$2 = Phaser.Math.Linear;
var AppendFromPathSegment = function (srcPathData, accumulationLengths, startT, endT, destPathData) {
if (endT === undefined) {
endT = startT;
startT = 0;
}
startT = WrapT(startT);
endT = WrapT(endT);
if (startT === endT) {
return;
}
var totalPathLength = accumulationLengths[accumulationLengths.length - 1];
var startL = totalPathLength * startT;
var endL = totalPathLength * endT;
if (startT < endT) {
AddPathSegment(srcPathData, accumulationLengths, startL, endL, destPathData);
} else {
AddPathSegment(srcPathData, accumulationLengths, startL, totalPathLength, destPathData);
AddPathSegment(srcPathData, accumulationLengths, 0, endL, destPathData);
}
DuplicateLast(destPathData);
};
var AddPathSegment = function (srcPathData, accumulationLengths, startL, endL, destPathData) {
var skipState = (startL > 0);
for (var i = 0, cnt = accumulationLengths.length; i < cnt; i++) {
var pIdx = i * 2;
var d = accumulationLengths[i];
if (skipState) {
if (d < startL) {
continue;
} else if (d == startL) {
skipState = false;
} else { // d > startL
var deltaD = d - accumulationLengths[i - 1];
var t = 1 - ((d - startL) / deltaD);
destPathData.push(GetInterpolation(srcPathData, pIdx - 2, pIdx, t));
destPathData.push(GetInterpolation(srcPathData, pIdx - 1, pIdx + 1, t));
skipState = false;
}
}
if (d <= endL) {
destPathData.push(srcPathData[pIdx]);
destPathData.push(srcPathData[pIdx + 1]);
if (d === endL) {
break;
}
} else { // d > endL
var deltaD = d - accumulationLengths[i - 1];
var t = 1 - ((d - endL) / deltaD);
destPathData.push(GetInterpolation(srcPathData, pIdx - 2, pIdx, t));
destPathData.push(GetInterpolation(srcPathData, pIdx - 1, pIdx + 1, t));
break;
}
}
};
var GetInterpolation = function (pathData, i0, i1, t) {
var p0 = pathData[i0], p1 = pathData[i1];
return Linear$2(p0, p1, t);
};
var WrapT = function (t) {
if (t === 0) {
return 0;
} else if ((t % 1) === 0) {
return 1;
}
return Wrap(t, 0, 1);
};
var PathSegmentMethods = {
updateAccumulationLengths() {
if (this.accumulationLengths == null) {
this.accumulationLengths = [];
} else if (this.accumulationLengths.length === (this.pathData.length / 2)) {
return this;
}
var accumulationLengths = this.accumulationLengths;
var pathData = this.pathData;
var prevX, prevY, x, y;
var d, accumulationLength = 0;
for (var i = 0, cnt = pathData.length; i < cnt; i += 2) {
x = pathData[i];
y = pathData[i + 1];
d = (prevX === undefined) ? 0 : DistanceBetween(prevX, prevY, x, y);
accumulationLength += d;
accumulationLengths.push(accumulationLength);
prevX = x;
prevY = y;
}
this.totalPathLength = accumulationLength;
return this;
},
setDisplayPathSegment(startT, endT) {
if (!this.pathDataSaved) {
this.updateAccumulationLengths();
this.savePathData();
}
this.pathData.length = 0;
AppendFromPathSegment(this.pathDataSave, this.accumulationLengths, startT, endT, this.pathData);
return this;
},
appendFromPathSegment(src, startT, endT) {
if (startT === undefined) {
this.pathData.push(...src.pathData);
} else {
src.updateAccumulationLengths();
AppendFromPathSegment(src.pathData, src.accumulationLengths, startT, endT, this.pathData);
}
this.firstPointX = this.pathData[0];
this.firstPointY = this.pathData[1];
this.lastPointX = this.pathData[this.pathData.length - 2];
this.lastPointY = this.pathData[this.pathData.length - 1];
return this;
},
};
var GraphicsMethods = {
draw(graphics, isFill, isStroke) {
var points = this.toPoints();
if (isFill) {
graphics.fillPoints(points, this.closePath, this.closePath);
}
if (isStroke) {
graphics.strokePoints(points, this.closePath, this.closePath);
}
return this;
}
};
var ToPoints = function (pathData, points) {
if (points === undefined) {
points = [];
}
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
points.push({
x: pathData[i],
y: pathData[i + 1]
});
}
return points;
};
//import Polygon from '../../utils/geom/polygon/Polygon.js';
const Polygon = Phaser.Geom.Polygon;
var ToPolygon = function (pathData, polygon) {
if (polygon === undefined) {
polygon = new Polygon();
}
polygon.setTo(pathData);
return polygon;
};
class PathDataBuilder {
constructor(pathData) {
if (pathData === undefined) {
pathData = [];
}
this.pathData = pathData;
this.closePath = false;
this.setIterations(32);
this.firstPointX = undefined;
this.firstPointY = undefined;
this.lastPointX = undefined;
this.lastPointY = undefined;
this.accumulationLengths = undefined;
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
toPoints() {
return ToPoints(this.pathData);
}
toPolygon(polygon) {
return ToPolygon(this.pathData, polygon);
}
}
Object.assign(
PathDataBuilder.prototype,
AddPathMethods,
TransformPointsMethods,
SavePathDataMethods,
PathSegmentMethods,
GraphicsMethods,
);
class Lines extends PathBase {
constructor() {
super();
this.builder = new PathDataBuilder(this.pathData);
}
get iterations() {
return this.builder.iterations;
}
set iterations(value) {
this.dirty = this.dirty || (this.builder.iterations !== value);
this.builder.setIterations(value);
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
get lastPointX() {
return this.builder.lastPointX;
}
get lastPointY() {
return this.builder.lastPointY;
}
start() {
this.builder.start();
this.dirty = true;
return this;
}
startAt(x, y) {
this.builder.startAt(x, y);
this.dirty = true;
return this;
}
lineTo(x, y, relative) {
this.builder.lineTo(x, y, relative);
this.dirty = true;
return this;
}
verticalLineTo(x, relative) {
this.builder.verticalLineTo(x, relative);
this.dirty = true;
return this;
}
horizontalLineTo(y, relative) {
this.builder.horizontalLineTo(y, relative);
this.dirty = true;
return this;
}
ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise) {
this.builder.ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise);
this.dirty = true;
return this;
}
arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise) {
this.builder.arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise);
this.dirty = true;
return this;
}
quadraticBezierTo(cx, cy, x, y) {
this.builder.quadraticBezierTo(cx, cy, x, y);
this.dirty = true;
return this;
}
cubicBezierTo(cx0, cy0, cx1, cy1, x, y) {
this.builder.cubicBezierTo(cx0, cy0, cx1, cy1, x, y);
this.dirty = true;
return this;
}
catmullRomTo(...points) {
this.builder.catmullRomTo(...points);
this.dirty = true;
return this;
}
close() {
this.builder.close();
this.closePath = this.builder.closePath;
this.dirty = true;
return this;
}
end() {
this.builder.end();
this.dirty = true;
return this;
}
rotateAround(centerX, centerY, angle) {
this.builder.rotateAround(centerX, centerY, angle);
this.dirty = true;
return this;
}
scale(centerX, centerY, scaleX, scaleY) {
this.builder.scale(centerX, centerY, scaleX, scaleY);
this.dirty = true;
return this;
}
offset(x, y) {
this.builder.offset(x, y);
this.dirty = true;
return this;
}
toPolygon(polygon) {
return this.builder.toPolygon(polygon);
}
appendPathFrom(src, startT, endT) {
this.builder.appendFromPathSegment(src.builder, startT, endT);
return this;
}
copyPathFrom(src, startT, endT) {
this.builder.clear().appendFromPathSegment(src.builder, startT, endT);
return this;
}
setDisplayPathSegment(startT, endT) {
this.builder.setDisplayPathSegment(startT, endT);
return this;
}
}
var Utils$1 = Phaser.Renderer.WebGL.Utils;
class Rectangle extends BaseGeom {
constructor(x, y, width, height) {
if (x === undefined) { x = 0; }
if (y === undefined) { y = 0; }
if (width === undefined) { width = 0; }
if (height === undefined) { height = width; }
super();
this.pathData = [];
this.closePath = true;
this.setTopLeftPosition(x, y);
this.setSize(width, height);
}
get x() {
return this._x;
}
set x(value) {
this.dirty = this.dirty || (this._x !== value);
this._x = value;
}
get y() {
return this._y;
}
set y(value) {
this.dirty = this.dirty || (this._y !== value);
this._y = value;
}
setTopLeftPosition(x, y) {
this.x = x;