phaser4-rex-plugins
Version:
1,697 lines (1,383 loc) • 85.4 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.rextoggleswitch = 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 StyleMethods$1 = {
setTrackFillStyle(color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.trackFillColor !== color) ||
(this.trackFillAlpha !== alpha);
this.trackFillColor = color;
this.trackFillAlpha = alpha;
return this;
},
setFalseValueTrackFillStyle(color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.falseValueTrackColor !== color) ||
(this.uncheckedTrackFillAlpha !== alpha);
this.falseValueTrackColor = color;
this.falseValueTrackFillAlpha = alpha;
return this;
},
setThumbStyle(color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.thumbColor !== color) ||
(this.checkAlpha !== alpha);
this.thumbColor = color;
this.thumbAlpha = alpha;
return this;
},
};
var SizeMethods = {
setTrackSize(width, height) {
this.dirty = this.dirty ||
(this.trackWidth !== width) ||
(this.trackHeight !== height);
this.trackWidth = width;
this.trackHeight = height;
return this;
},
setTrackRadius(radius) {
this.dirty = this.dirty ||
(this.trackRadius !== radius);
this.trackRadius = radius;
return this;
},
setThumbSize(width, height) {
if (height === undefined) {
height = width;
}
this.dirty = this.dirty ||
(this.thumbWidth !== width) ||
(this.thumbHeight !== height);
this.thumbWidth = width;
this.thumbHeight = height;
return this;
},
setThumbRadius(radius) {
this.dirty = this.dirty ||
(this.thumbRadius !== radius);
this.thumbRadius = radius;
return this;
},
};
var PositionMethods = {
setThumbPosition(left, right) {
if (right === undefined) {
right = 1 - left;
}
this.thumbLeftX = left;
this.thumbRightX = right;
return this;
},
setRTL(rtl) {
if (rtl === undefined) {
rtl = true;
}
this.rtl = rtl;
return this;
}
};
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$a = 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$a(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$1 = 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$1.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 = Phaser.Renderer.WebGL.Utils;
var StrokePathWebGL = function (drawingContext, submitter, matrix, gameObject, shapeData, alpha, dx, dy) {
var strokeTintColor = Utils.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$1 = 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$1(deltaAngle) / iteration;
startAngle = DegToRad$1(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;
};
Phaser.Math.DegToRad;
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$3 = 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$3(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,
);
Phaser.Renderer.WebGL.Utils;
const GetValue$9 = Phaser.Utils.Objects.GetValue;
class RoundRectangle extends PathBase {
constructor(x, y, width, height, radius, iterations) {
if (x === undefined) { x = 0; }
if (y === undefined) { y = 0; }
if (width === undefined) { width = 0; }
if (height === undefined) { height = width; }
if (radius === undefined) { radius = 0; }
if (iterations === undefined) { iterations = 6; }
super();
this.setTopLeftPosition(x, y);
this.setSize(width, height);
this.setRadius(radius);
this.setIterations(iterations);
this.closePath = true;
}
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;
this.y = y;
return this;
}
get width() {
return this._width;
}
set width(value) {
this.dirty = this.dirty || (this._width !== value);
this._width = value;
}
get height() {
return this._height;
}
set height(value) {
this.dirty = this.dirty || (this._height !== value);
this._height = value;
}
setSize(width, height) {
this.width = width;
this.height = height;
return this;
}
get centerX() {
return this.x + (this.width / 2);
}
set centerX(value) {
this.x = value - (this.width / 2);
}
get centerY() {
return this.y + (this.height / 2);
}
set centerY(value) {
this.y = value - (this.height / 2);
}
setCenterPosition(x, y) {
this.centerX = x;
this.centerY = y;
return this;
}
get radiusTL() {
return this._radiusTL;
}
set radiusTL(value) {
var isConvex = (value > 0);
this.dirty = this.dirty || (this._radiusTL !== value) || (this._convexTL !== isConvex);
this._convexTL = isConvex;
this._radiusTL = Math.abs(value);
}
get radiusTR() {
return this._radiusTR;
}
set radiusTR(value) {
var isConvex = (value > 0);
this.dirty = this.dirty || (this._radiusTR !== value) || (this._convexTR !== isConvex);
this._convexTR = isConvex;
this._radiusTR = Math.abs(value);
}
get radiusBL() {
return this._radiusBL;
}
set radiusBL(value) {
var isConvex = (value > 0);
this.dirty = this.dirty || (this._radiusBL !== value) || (this._convexBL !== isConvex);
this._convexBL = isConvex;
this._radiusBL = Math.abs(value);
}
get radiusBR() {
return this._radiusBR;
}
set radiusBR(value) {
var isConvex = (value > 0);
this.dirty = this.dirty || (this._radiusBR !== value) || (this._convexBR !== isConvex);
this._convexBR = isConvex;
this._radiusBR = Math.abs(value);
}
get radius() {
return Math.max(this.radiusTL, this.radiusTR, this.radiusBL, this.radiusBR,);
}
set radius(value) {
if (typeof (value) === 'number') {
this.radiusTL = value;
this.radiusTR = value;
this.radiusBL = value;
this.radiusBR = value;
} else {
this.radiusTL = GetValue$9(value, 'tl', 0);
this.radiusTR = GetValue$9(value, 'tr', 0);
this.radiusBL = GetValue$9(value, 'bl', 0);
this.radiusBR = GetValue$9(value, 'br', 0);
}
}
setRadius(radius) {
if (radius === undefined) {
radius = 0;
}
this.radius = radius;
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() {
var pathData = this.pathData;
pathData.length = 0;
var width = this.width, height = this.height,
radius,
iterations = this.iterations + 1;
// top-left
radius = this.radiusTL;
if (radius > 0) {
if (this._convexTL) {
var centerX = radius;
var centerY = radius;
ArcTo(centerX, centerY, radius, radius, 180, 270, false, iterations, pathData);
} else {
var centerX = 0;
var centerY = 0;
ArcTo(centerX, centerY, radius, radius, 90, 0, true, iterations, pathData);
}
} else {
LineTo(0, 0, pathData);
}
// top-right
radius = this.radiusTR;
if (radius > 0) {
if (this._convexTR) {
var centerX = width - radius;
var centerY = radius;
ArcTo(centerX, centerY, radius, radius, 270, 360, false, iterations, pathData);
} else {
var centerX = width;
var centerY = 0;
ArcTo(centerX, centerY, radius, radius, 180, 90, true, iterations, pathData);
}
} else {
LineTo(width, 0, pathData);
}
// bottom-right
radius = this.radiusBR;
if (radius > 0) {
if (this._convexBR) {
var centerX = width - radius;
var centerY = height - radius;
ArcTo(centerX, centerY, radius, radius, 0, 90, false, iterations, pathData);
} else {
var centerX = width;
var centerY = height;
ArcTo(centerX, centerY, radius, radius, 270, 180, true, iterations, pathData);
}
} else {
LineTo(width, height, pathData);
}
// bottom-left
radius = this.radiusBL;
if (radius > 0) {
if (this._convexBL) {
var centerX = radius;
var centerY = height - radius;
ArcTo(centerX, centerY, radius, radius, 90, 180, false, iterations, pathData);
} else {
var centerX = 0;
var centerY = height;
ArcTo(centerX, centerY, radius, radius, 360, 270, true, iterations, pathData);
}
} else {
LineTo(0, height, pathData);
}
pathData.push(pathData[0], pathData[1]); // Repeat first point to close curve
Offset(this.x, this.y, pathData);
super.updateData();
return this;
}
}
Phaser.Renderer.WebGL.Utils;
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2019 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
/**
* Calculates a linear (interpolation) value over t.
*
* @function Phaser.Math.Linear
* @since 3.0.0
*
* @param {number} p0 - The first point.
* @param {number} p1 - The second point.
* @param {number} t - The percentage between p0 and p1 to return, represented as a number between 0 and 1.
*
* @return {number} The step t% of the way between p0 and p1.
*/
var Linear$2 = function (p0, p1, t)
{
return (p1 - p0) * t + p0;
};
var GetR = function (colorInt) {
return (colorInt >> 16) & 0xff;
};
var GetG = function (colorInt) {
return (colorInt >> 8) & 0xff;
};
var GetB = function (colorInt) {
return (colorInt) & 0xff;
};
var MixColor = function (color0, color1, t) {
var r = Linear$2(GetR(color0), GetR(color1), t);
var g = Linear$2(GetG(color0), GetG(color1), t);
var b = Linear$2(GetB(color0), GetB(color1), t);
return ((r & 0xff) << 16) | ((g & 0xff) << 8) | ((b & 0xff));
};
const Linear$1 = Phaser.Math.Linear;
var ShapesUpdateMethods = {
buildShapes() {
this
.addShape(new RoundRectangle().setName('track'))
.addShape(new RoundRectangle().setName('thumb'));
},
updateShapes() {
var width = this.width,
height = this.height;
var toggleAnimProgress = (this.value) ? this.toggleAnimProgress : (1 - this.toggleAnimProgress);
// Track
var trackShape = this.getShape('track');
if (this.isSizeChanged) {
var trackWidth = width * this.trackWidth,
trackHeight = height * this.trackHeight,
trackX = (width - trackWidth) / 2,
trackY = (height - trackHeight) / 2,
trackRadius = height * this.trackRadius;
trackShape
.setTopLeftPosition(trackX, trackY)
.setSize(trackWidth, trackHeight)
.setRadius(trackRadius);
}
var trackFillColor = MixColor(this.falseValueTrackColor, this.trackFillColor, toggleAnimProgress);
var trackFillAlpha = Linear$1(this.falseValueTrackFillAlpha, this.trackFillAlpha, toggleAnimProgress);
trackShape
.fillStyle(trackFillColor, trackFillAlpha);
// Thumb
var thumbShape = this.getShape('thumb');
if (this.isSizeChanged) {
var thumbWidth = width * this.thumbWidth,
thumbHeight = height * this.thum