phaser4-rex-plugins
Version:
1,716 lines (1,390 loc) • 524 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.rextextplayerplugin = factory());
})(this, (function () { 'use strict';
var EventEmitterMethods$1 = {
setEventEmitter(eventEmitter, EventEmitterClass) {
if (EventEmitterClass === undefined) {
EventEmitterClass = Phaser.Events.EventEmitter; // Use built-in EventEmitter class by default
}
this._privateEE = (eventEmitter === true) || (eventEmitter === undefined);
this._eventEmitter = (this._privateEE) ? (new EventEmitterClass()) : eventEmitter;
return this;
},
destroyEventEmitter() {
if (this._eventEmitter && this._privateEE) {
this._eventEmitter.shutdown();
}
return this;
},
getEventEmitter() {
return this._eventEmitter;
},
on() {
if (this._eventEmitter) {
this._eventEmitter.on.apply(this._eventEmitter, arguments);
}
return this;
},
once() {
if (this._eventEmitter) {
this._eventEmitter.once.apply(this._eventEmitter, arguments);
}
return this;
},
off() {
if (this._eventEmitter) {
this._eventEmitter.off.apply(this._eventEmitter, arguments);
}
return this;
},
emit(event) {
if (this._eventEmitter && event) {
this._eventEmitter.emit.apply(this._eventEmitter, arguments);
}
return this;
},
addListener() {
if (this._eventEmitter) {
this._eventEmitter.addListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeListener() {
if (this._eventEmitter) {
this._eventEmitter.removeListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeAllListeners() {
if (this._eventEmitter) {
this._eventEmitter.removeAllListeners.apply(this._eventEmitter, arguments);
}
return this;
},
listenerCount() {
if (this._eventEmitter) {
return this._eventEmitter.listenerCount.apply(this._eventEmitter, arguments);
}
return 0;
},
listeners() {
if (this._eventEmitter) {
return this._eventEmitter.listeners.apply(this._eventEmitter, arguments);
}
return [];
},
eventNames() {
if (this._eventEmitter) {
return this._eventEmitter.eventNames.apply(this._eventEmitter, arguments);
}
return [];
},
};
var PropertyMethods$1 = {
hasProperty(property) {
var gameObject = this.gameObject;
if (gameObject.hasOwnProperty(property)) {
return true;
} else {
var value = gameObject[property];
return (value !== undefined);
}
},
getProperty(property) {
return this.gameObject[property];
},
setProperty(property, value) {
this.gameObject[property] = value;
return this;
},
easeProperty(config) {
var property = config.property;
var value = config.value;
var duration = config.duration;
var delay = config.delay;
var ease = config.ease;
var repeat = config.repeat;
var isYoyo = config.yoyo;
var isFrom = config.from;
var onComplete = config.complete;
var target = config.target;
if (duration === undefined) {
duration = 1000;
}
if (delay === undefined) {
delay = 0;
}
if (ease === undefined) {
ease = 'Linear';
}
if (repeat === undefined) {
repeat = 0;
}
if (isYoyo === undefined) {
isYoyo = false;
}
if (target === undefined) {
target = this.gameObject;
}
if (isFrom) {
var startValue = value;
value = target[property];
target[property] = startValue;
}
var config = {
targets: target,
duration: duration,
delay: delay,
ease: ease,
repeat: repeat,
yoyo: isYoyo,
onComplete: onComplete,
};
config[property] = value;
this.addTweenTask(property, config);
return this;
},
addTweenTask(name, config) {
var tweenTasks = this.tweens;
var tweenTask = tweenTasks[name];
if (tweenTask) {
tweenTask.remove();
}
var onComplete = config.onComplete;
config.onComplete = function () {
tweenTasks[name].remove();
tweenTasks[name] = null;
if (onComplete) {
onComplete(config.targets, name);
}
};
tweenTask = this.scene.tweens.add(config);
tweenTask.timeScale = this.timeScale;
tweenTasks[name] = tweenTask;
return this;
},
getTweenTask(property) {
return this.tweens[property];
},
freeTweens() {
var tweenTasks = this.tweens,
tweenTask;
for (var propName in tweenTasks) {
tweenTask = tweenTasks[propName];
if (tweenTask) {
tweenTask.remove();
}
tweenTasks[propName] = null;
}
return this;
}
};
var CallMethods$1 = {
hasMethod(methodName) {
return typeof (this.gameObject[methodName]) === 'function';
},
call(methodName, ...parameters) {
if (!this.hasMethod(methodName)) {
console.warn(`[GameObjectManager] Game object '${this.name}' does not have method '${methodName}'`);
return this;
}
var gameObject = this.gameObject;
gameObject[methodName].apply(gameObject, parameters);
return this;
}
};
var DataMethods$2 = {
hasData(dataKey) {
var gameObject = this.gameObject;
return (gameObject.data) ? gameObject.data.has(dataKey) : false;
},
getData(dataKey) {
return this.gameObject.getData(dataKey);
},
setData(dataKey, value) {
this.gameObject.setData(dataKey, value);
return this;
},
};
class BobBase {
constructor(GOManager, gameObject, name) {
this.GOManager = GOManager;
this.tweens = {};
this.effects = {};
this.setGO(gameObject, name);
}
get scene() {
return this.GOManager.scene;
}
get timeScale() {
return this.GOManager.timeScale;
}
destroy() {
this.freeGO();
this.GOManager = undefined;
}
freeGO() {
this.freeTweens();
this.gameObject.bob = undefined;
this.gameObject.destroy();
this.gameObject = undefined;
return this;
}
setGO(gameObject, name) {
gameObject.goName = name;
gameObject.goType = this.GOManager.name;
gameObject.bob = this;
this.gameObject = gameObject;
this.name = name;
this.freeTweens();
return this;
}
setTimeScale(timeScale) {
var tweenTasks = this.tweens;
for (var key in tweenTasks) {
var tweenTask = tweenTasks[key];
if (tweenTask) {
tweenTask.timeScale = timeScale;
}
}
return this;
}
}
Object.assign(
BobBase.prototype,
PropertyMethods$1,
CallMethods$1,
DataMethods$2,
);
var IsEmpty = function (source) {
for (var k in source) {
return false;
}
return true;
};
var IsSingleBob = function (name) {
return name && (name.charAt(0) !== '!');
};
var GetMethods = {
has(name) {
return this.bobs.hasOwnProperty(name);
},
exists(name) {
return this.bobs.hasOwnProperty(name);
},
get(name, out) {
if (IsSingleBob(name)) {
return this.bobs[name];
} else {
if (out === undefined) {
out = [];
}
if (name) {
name = name.substring(1);
}
for (var key in this.bobs) {
if (name && (key === name)) {
continue;
}
out.push(this.bobs[key]);
}
return out;
}
},
getFitst(excluded) {
if (excluded && (excluded.charAt(0) === '!')) {
excluded = excluded.substring(1);
}
for (var name in this.bobs) {
if (excluded && (excluded === name)) {
continue;
}
return this.bobs[name];
}
return null;
},
getGO(name, out) {
var bob = this.get(name);
if (!bob) {
return null;
} else if (!Array.isArray(bob)) {
return bob.gameObject;
} else {
if (out === undefined) {
out = [];
}
var bobs = bob;
bobs.forEach(function (bob) {
out.push(bob.gameObject);
});
return out;
}
},
forEachGO(callback, scope) {
for (var name in this.bobs) {
var gameObject = this.bobs[name].gameObject;
var stopLoop;
if (scope) {
stopLoop = callback.call(scope, gameObject, name, this);
} else {
stopLoop = callback(gameObject, name, this);
}
if (stopLoop) {
break;
}
}
return this;
},
getAllGO(out) {
if (out === undefined) {
out = [];
}
for (var name in this.bobs) {
var gameObject = this.bobs[name].gameObject;
out.push(gameObject);
}
return out;
}
};
var GetR = function (colorInt) {
return (colorInt >> 16) & 0xff;
};
var GetG = function (colorInt) {
return (colorInt >> 8) & 0xff;
};
var GetB = function (colorInt) {
return (colorInt) & 0xff;
};
const MaskR = (~(0xff << 16) & 0xffffff);
const MaskG = (~(0xff << 8) & 0xffffff);
const MaskB = (~(0xff) & 0xffffff);
var SetR = function (colorInt, r) {
return ((r & 0xff) << 16) | (colorInt & MaskR);
};
var SetG = function (colorInt, g) {
return ((g & 0xff) << 8) | (colorInt & MaskG);
};
var SetB = function (colorInt, b) {
return (b & 0xff) | (colorInt & MaskB);
};
var SetRGB = function (colorInt, r, g, b) {
return ((r & 0xff) << 16) | ((g & 0xff) << 8) | ((b & 0xff));
};
var AddTintRGBProperties = function (gameObject, tintRGB) {
// Don't attach properties again
if (gameObject.hasOwnProperty('tintR')) {
return gameObject;
}
if (tintRGB === undefined) {
tintRGB = 0xffffff;
}
var tintR = GetR(tintRGB);
var tintG = GetG(tintRGB);
var tintB = GetB(tintRGB);
// Override tint property
Object.defineProperty(gameObject, 'tint', {
get: function () {
return tintRGB;
},
set: function (value) {
value = Math.floor(value) & 0xffffff;
if (gameObject.setTint) {
gameObject.setTint(value);
}
if (tintRGB !== value) {
tintRGB = value;
tintR = GetR(tintRGB);
tintG = GetG(tintRGB);
tintB = GetB(tintRGB);
// gameObject.emit('_tintchange', value, tintR, tintG, tintB);
}
}
});
Object.defineProperty(gameObject, 'tintR', {
get: function () {
return tintR;
},
set: function (value) {
value = Math.floor(value) & 0xff;
if (tintR !== value) {
tintR = value;
gameObject.tint = SetR(tintRGB, value);
}
},
});
Object.defineProperty(gameObject, 'tintG', {
get: function () {
return tintG;
},
set: function (value) {
value = Math.floor(value) & 0xff;
if (tintG !== value) {
tintG = value;
gameObject.tint = SetG(tintRGB, value);
}
},
});
Object.defineProperty(gameObject, 'tintB', {
get: function () {
return tintB;
},
set: function (value) {
value = Math.floor(value) & 0xff;
if (tintB !== value) {
tintB = value;
gameObject.tint = SetB(tintRGB, value);
}
},
});
Object.defineProperty(gameObject, 'tintGray', {
get: function () {
return Math.floor((tintR + tintG + tintB) / 3);
},
set: function (value) {
value = Math.floor(value) & 0xff;
if ((tintR !== value) || (tintG !== value) || (tintB !== value)) {
tintR = value;
tintG = value;
tintB = value;
gameObject.tint = SetRGB(tintRGB, value, value, value);
}
},
});
gameObject.tint = tintRGB;
return gameObject;
};
const EventEmitter$1 = Phaser.Events.EventEmitter;
var MonitorViewport = function (viewport) {
// Don't monitor properties again
if (viewport.events) {
return viewport;
}
var events = new EventEmitter$1();
var x = viewport.x;
Object.defineProperty(viewport, 'x', {
get: function () {
return x;
},
set: function (value) {
if (x !== value) {
x = value;
events.emit('update', viewport);
}
},
});
var y = viewport.y;
Object.defineProperty(viewport, 'y', {
get: function () {
return y;
},
set: function (value) {
if (y !== value) {
y = value;
events.emit('update', viewport);
}
},
});
var width = viewport.width;
Object.defineProperty(viewport, 'width', {
get: function () {
return width;
},
set: function (value) {
if (width !== value) {
width = value;
events.emit('update', viewport);
}
},
});
var height = viewport.height;
Object.defineProperty(viewport, 'height', {
get: function () {
return height;
},
set: function (value) {
if (height !== value) {
height = value;
events.emit('update', viewport);
}
},
});
viewport.events = events;
return viewport;
};
var VPXYToXY = function (vpx, vpy, vpxOffset, vpyOffset, viewport, out) {
if (out === undefined) {
out = {};
} else if (out === true) {
out = GlobXY;
}
if (typeof (vpxOffset) !== 'number') {
vpxOffset = 0;
vpyOffset = 0;
}
out.x = viewport.x + (viewport.width * vpx) + vpxOffset;
out.y = viewport.y + (viewport.height * vpy) + vpyOffset;
return out;
};
var GlobXY = {};
var AddViewportCoordinateProperties = function (gameObject, viewport, vpx, vpy, vpxOffset, vpyOffset, transformCallback) {
// Don't attach properties again
if (gameObject.hasOwnProperty('vp')) {
return gameObject;
}
if (typeof (vpx) === 'function') {
transformCallback = vpx;
vpx = undefined;
}
if (typeof (vpxOffset) === 'function') {
transformCallback = vpxOffset;
vpxOffset = undefined;
}
if (vpx === undefined) { vpx = 0.5; }
if (vpy === undefined) { vpy = 0.5; }
if (vpxOffset === undefined) { vpxOffset = 0; }
if (vpyOffset === undefined) { vpyOffset = 0; }
if (transformCallback === undefined) {
transformCallback = VPXYToXY;
}
MonitorViewport(viewport);
var events = viewport.events;
gameObject.vp = viewport;
// Set position of game object when view-port changed.
var Transform = function () {
transformCallback(vpx, vpy, vpxOffset, vpyOffset, viewport, gameObject);
};
events.on('update', Transform);
gameObject.once('destroy', function () {
events.off('update', Transform);
gameObject.vp = undefined;
});
Object.defineProperty(gameObject, 'vpx', {
get: function () {
return vpx;
},
set: function (value) {
if (vpx !== value) {
vpx = value;
Transform();
}
},
});
Object.defineProperty(gameObject, 'vpy', {
get: function () {
return vpy;
},
set: function (value) {
if (vpy !== value) {
vpy = value;
Transform();
}
},
});
Object.defineProperty(gameObject, 'vpxOffset', {
get: function () {
return vpxOffset;
},
set: function (value) {
if (vpxOffset !== value) {
vpxOffset = value;
Transform();
}
},
});
Object.defineProperty(gameObject, 'vpyOffset', {
get: function () {
return vpyOffset;
},
set: function (value) {
if (vpyOffset !== value) {
vpyOffset = value;
Transform();
}
},
});
Transform();
};
var HasProperty = function (obj, prop) {
if (!obj) {
return false;
}
if (obj.hasOwnProperty(prop)) {
return true;
}
while (obj) {
if (Object.getOwnPropertyDescriptor(obj, prop)) {
return true;
}
obj = obj.__proto__;
}
return false;
};
var GetFilterList = function (gameObject, external) {
if (external === undefined) {
external = false;
}
if (!gameObject.filters) {
gameObject.enableFilters().focusFilters();
}
var filterList = (!external) ? gameObject.filters.internal : gameObject.filters.external;
return filterList;
};
var AddClearEffectCallback = function (gameObject, effectSwitchName) {
if (!gameObject._effectSwitchNames) {
gameObject._effectSwitchNames = [];
gameObject.clearAllEffects = function () {
var effectSwitchNames = gameObject._effectSwitchNames;
for (var i = 0, cnt = effectSwitchNames.length; i < cnt; i++) {
gameObject[effectSwitchNames[i]] = null;
}
return gameObject;
};
gameObject.on('destroy', gameObject.clearAllEffects, gameObject);
}
gameObject._effectSwitchNames.push(effectSwitchName);
};
var AddBarrelProperties = function (gameObject) {
// Don't attach properties again
if (HasProperty(gameObject, 'barrel')) {
return gameObject;
}
var filterList = GetFilterList(gameObject);
var barrel;
Object.defineProperty(gameObject, 'barrel', {
get: function () {
return barrel;
},
set: function (value) {
if (barrel === value) {
return;
}
barrel = value;
if ((barrel === null) || (barrel === false)) {
if (gameObject._barrelEffect) {
filterList.remove(gameObject._barrelEffect);
gameObject._barrelEffect = undefined;
}
} else {
if (!gameObject._barrelEffect) {
gameObject._barrelEffect = filterList.addBarrel();
}
gameObject._barrelEffect.amount = barrel;
}
},
});
gameObject.barrel = null;
AddClearEffectCallback(gameObject, 'barrel');
return gameObject;
};
var AddColorMatrixEffectPropertiesBase = function (gameObject, effectName, inputMode) {
// Don't attach properties again
if (HasProperty(gameObject, effectName)) {
return gameObject;
}
var filterList = GetFilterList(gameObject);
var EffectInstancePropertyName = `_${effectName}Effect`;
var currentValue;
Object.defineProperty(gameObject, effectName, {
get: function () {
return currentValue;
},
set: function (value) {
if (currentValue === value) {
return;
}
currentValue = value;
if ((currentValue === null) || (currentValue === false)) {
if (gameObject[EffectInstancePropertyName]) {
filterList.remove(gameObject[EffectInstancePropertyName]);
gameObject[EffectInstancePropertyName] = undefined;
}
} else {
if (!gameObject[EffectInstancePropertyName]) {
gameObject[EffectInstancePropertyName] = filterList.addColorMatrix();
}
var effectInstance = gameObject[EffectInstancePropertyName];
effectInstance.colorMatrix[effectName]((inputMode === 1) ? value : undefined);
}
},
});
gameObject[effectName] = null;
AddClearEffectCallback(gameObject, effectName);
return gameObject;
};
var AddBlackWhiteProperties = function (gameObject) {
AddColorMatrixEffectPropertiesBase(gameObject, 'blackWhite');
return gameObject;
};
var AddBlockyProperties = function (gameObject) {
// Don't attach properties again
if (HasProperty(gameObject, 'blockySize')) {
return gameObject;
}
var filterList = GetFilterList(gameObject);
var blockySize,
blockyOffsetX = 0,
blockyOffsetY = 0;
Object.defineProperty(gameObject, 'blockySize', {
get: function () {
return blockySize;
},
set: function (value) {
if (blockySize === value) {
return;
}
blockySize = value;
if ((blockySize === null) || (blockySize === false)) {
if (gameObject._blockyEffect) {
filterList.remove(gameObject._blockyEffect);
gameObject._blockyEffect = undefined;
}
} else {
if (!gameObject._blockyEffect) {
gameObject._blockyEffect = filterList.addBlocky({
size: blockySize,
offset: { x: blockyOffsetX, y: blockyOffsetY },
});
}
gameObject._blockyEffect.size.x = blockySize;
gameObject._blockyEffect.size.y = blockySize;
}
},
});
Object.defineProperty(gameObject, 'blockyOffsetX', {
get: function () {
return blockyOffsetX;
},
set: function (value) {
if (blockyOffsetX === value) {
return;
}
blockyOffsetX = value;
if (gameObject._blockyEffect) {
gameObject._blockyEffect.offset.x = blockyOffsetX;
}
},
});
Object.defineProperty(gameObject, 'blockyOffsetY', {
get: function () {
return blockyOffsetY;
},
set: function (value) {
if (blockyOffsetY === value) {
return;
}
blockyOffsetY = value;
if (gameObject._blockyEffect) {
gameObject._blockyEffect.offset.y = blockyOffsetY;
}
},
});
AddClearEffectCallback(gameObject, 'blockySize');
return gameObject;
};
const GameClass = Phaser.Game;
var IsGame = function (object) {
return (object instanceof GameClass);
};
const SceneClass = Phaser.Scene;
var IsSceneObject = function (object) {
return (object instanceof SceneClass);
};
var GetGame = function (object) {
if ((object == null) || (typeof (object) !== 'object')) {
return null;
} else if (IsGame(object)) {
return object;
} else if (IsGame(object.game)) {
return object.game;
} else if (IsSceneObject(object)) { // object = scene object
return object.sys.game;
} else if (IsSceneObject(object.scene)) { // object = game object
return object.scene.sys.game;
}
};
var RegisterFilter = function (game, FilterClass) {
var filterName = FilterClass.FilterName;
var renderNodes = GetGame(game).renderer.renderNodes;
if (renderNodes.hasNode(filterName)) {
return false;
}
renderNodes.addNodeConstructor(filterName, FilterClass);
return true;
};
var AddFilterListMethod = function (name, callback) {
var FilterListComponent = Phaser.GameObjects.Components.FilterList.prototype;
if (FilterListComponent[name]) {
return;
}
FilterListComponent[name] = callback;
};
const StepFilterName = 'FilterP3BloomStep';
// Built-in fx in phaser3
const frag$5 = `\
#pragma phaserTemplate(shaderName)
#ifdef GL_FRAGMENT_PRECISION_HIGH
#define highmedp highp
#else
#define highmedp mediump
#endif
precision highmedp float;
// Scene buffer
uniform sampler2D uMainSampler;
varying vec2 outTexCoord;
// Effect parameters
uniform vec2 offset;
uniform float strength;
uniform vec3 color;
#pragma phaserTemplate(fragmentHeader)
void main (void) {
vec4 sum = texture2D(uMainSampler, outTexCoord) * 0.204164 * strength;
sum = sum + texture2D(uMainSampler, outTexCoord + offset * 1.407333) * 0.304005;
sum = sum + texture2D(uMainSampler, outTexCoord - offset * 1.407333) * 0.304005;
sum = sum + texture2D(uMainSampler, outTexCoord + offset * 3.294215) * 0.093913;
sum = sum + texture2D(uMainSampler, outTexCoord - offset * 3.294215) * 0.093913;
gl_FragColor = sum * vec4(color, 1);
}
`;
class BloomStepFilter extends Phaser.Renderer.WebGL.RenderNodes.BaseFilterShader {
static FilterName = StepFilterName;
constructor(manager) {
super(StepFilterName, manager, null, frag$5);
}
// This method sets up the uniforms for the shader.
setupUniforms(controller, drawingContext) {
const programManager = this.programManager;
var x = (2 / drawingContext.width) * controller.offsetX;
var y = (2 / drawingContext.height) * controller.offsetY;
programManager.setUniform('offset', [x, y]);
programManager.setUniform('strength', controller.strength);
programManager.setUniform('color', controller.glcolor);
}
}
const GetValue$C = Phaser.Utils.Objects.GetValue;
class BloomStepController extends Phaser.Filters.Controller {
static FilterName = StepFilterName;
constructor(camera, config) {
super(camera, StepFilterName);
this.offsetX = 1;
this.offsetY = 1;
this.strength = 1;
this.glcolor = [1, 1, 1];
this.resetFromJSON(config);
}
resetFromJSON(o) {
this.setOffset(GetValue$C(o, 'offsetX', 1), GetValue$C(o, 'offsetY', 1));
this.setStrength(GetValue$C(o, 'strength', 1));
this.setColor(GetValue$C(o, 'color', 0xFFFFFF));
return this;
}
get color() {
var color = this.glcolor;
return (((color[0] * 255) << 16) + ((color[1] * 255) << 8) + (color[2] * 255 | 0));
}
set color(value) {
var color = this.glcolor;
color[0] = ((value >> 16) & 0xFF) / 255;
color[1] = ((value >> 8) & 0xFF) / 255;
color[2] = (value & 0xFF) / 255;
}
setOffset(x, y) {
this.offsetX = x;
this.offsetY = y;
return this;
}
setStrength(strength) {
this.strength = strength;
return this;
}
setColor(color) {
this.color = color;
return this;
}
}
const GetValue$B = Phaser.Utils.Objects.GetValue;
let BloomController$1 = class BloomController extends Phaser.Filters.ParallelFilters {
constructor(camera, config) {
super(camera);
this.steps = 0;
this.offsetX = 1;
this.offsetY = 1;
this.blurStrength = 1;
this.color = 0xffffff;
this.strength = 1;
this.resetFromJSON(config);
}
resetFromJSON(o) {
this.setOffset(GetValue$B(o, 'offsetX', 1), GetValue$B(o, 'offsetY', 1));
this.setBlurStrength(GetValue$B(o, 'blurStrength', 1));
this.setColor(GetValue$B(o, 'color', 0xFFFFFF));
this.setStrength(GetValue$B(o, 'strength', 1));
this.setSteps(GetValue$B(o, 'steps', 4));
return this;
}
forEachController(callback, scope) {
this.top.list.forEach(callback, scope);
}
get steps() {
return this._steps;
}
set steps(value) {
if (this._steps === value) {
return;
}
var camera = this.camera;
if (this.steps < value) {
var filters = this.top;
var startIndex = this.steps * 2;
var stopIndex = value * 2;
for (var i = startIndex; i < stopIndex; i++) {
filters.add(new BloomStepController(camera));
}
} else { // this.steps > value
var filtersList = this.top.list;
var startIndex = this.steps * 2;
var stopIndex = value * 2;
for (var i = startIndex - 1; i >= stopIndex; i--) {
filtersList[i].destroy();
}
filtersList.length = stopIndex;
}
this._steps = value;
this.setOffset(this.offsetX, this.offsetY);
this.setBlurStrength(this.strength);
this.setColor(this.color);
}
setSteps(steps) {
this.steps = steps;
return this;
}
get offsetX() {
return this._offsetX;
}
set offsetX(value) {
this._offsetX = value;
this.forEachController(function (bloomStepController, i) {
bloomStepController.offsetX = (i % 2 === 0) ? value : 0;
});
}
get offsetY() {
return this._offsetY;
}
set offsetY(value) {
this._offsetY = value;
this.forEachController(function (bloomStepController, i) {
bloomStepController.offsetY = (i % 2 === 1) ? value : 0;
});
}
setOffset(x, y) {
this.offsetX = x;
this.offsetY = y;
return this;
}
get blurStrength() {
return this._blurStrength;
}
set blurStrength(value) {
this._blurStrength = value;
this.forEachController(function (bloomStepController) {
bloomStepController.strength = value;
});
}
setBlurStrength(blurStrength) {
this.blurStrength = blurStrength;
return this;
}
get color() {
return this._color;
}
set color(value) {
this._color = value;
this.forEachController(function (bloomStepController) {
bloomStepController.color = value;
});
}
setColor(color) {
this.color = color;
return this;
}
get strength() {
return this._strength;
}
set strength(value) {
this._strength = value;
this.blend.amount = value;
}
setStrength(strength) {
this.strength = strength;
return this;
}
};
var InstallBloomFX = function (game) {
game = GetGame(game);
var success = RegisterFilter(game, BloomStepFilter);
if (!success) {
return false;
}
AddFilterListMethod(
'addP3Bloom',
function (color, offsetX, offsetY, blurStrength, strength, steps) {
if (color === undefined) { color = 0xFFFFFF; }
if (offsetX === undefined) { offsetX = 1; }
if (offsetY === undefined) { offsetY = 1; }
if (blurStrength === undefined) { blurStrength = 1; }
if (strength === undefined) { strength = 1; }
if (steps === undefined) { steps = 4; }
return this.add(new BloomController$1(
this.camera,
{ color, offsetX, offsetY, blurStrength, strength, steps }
));
}
);
return true;
};
var AddBloomProperties = function (gameObject) {
// Don't attach properties again
if (HasProperty(gameObject, 'bloomColor')) {
return gameObject;
}
InstallBloomFX(gameObject);
var filterList = GetFilterList(gameObject);
var bloomColor,
bloomOffsetX = 1,
bloomOffsetY = 1,
bloomBlurStrength = 1,
bloomStrength = 1,
bloomSteps = 4;
Object.defineProperty(gameObject, 'bloomColor', {
get: function () {
return bloomColor;
},
set: function (value) {
if (bloomColor === value) {
return;
}
bloomColor = value;
if ((bloomColor === null) || (bloomColor === false)) {
if (gameObject._bloom) {
filterList.remove(gameObject._bloom);
gameObject._bloom = undefined;
}
} else {
if (!gameObject._bloom) {
gameObject._bloom = filterList.addBloom(bloomColor, bloomOffsetX, bloomOffsetY, bloomBlurStrength, bloomStrength, bloomSteps);
}
gameObject._bloom.color = bloomColor;
}
},
});
Object.defineProperty(gameObject, 'bloomOffsetX', {
get: function () {
return bloomOffsetX;
},
set: function (value) {
if (bloomOffsetX === value) {
return;
}
bloomOffsetX = value;
if (gameObject._bloom) {
gameObject._bloom.offsetX = bloomOffsetX;
}
},
});
Object.defineProperty(gameObject, 'bloomOffsetY', {
get: function () {
return bloomOffsetY;
},
set: function (value) {
if (bloomOffsetY === value) {
return;
}
bloomOffsetY = value;
if (gameObject._bloom) {
gameObject._bloom.offsetY = bloomOffsetY;
}
},
});
Object.defineProperty(gameObject, 'bloomBlurStrength', {
get: function () {
return bloomBlurStrength;
},
set: function (value) {
if (bloomBlurStrength === value) {
return;
}
bloomBlurStrength = value;
if (gameObject._bloom) {
gameObject._bloom.blurStrength = bloomBlurStrength;
}
},
});
Object.defineProperty(gameObject, 'bloomStrength', {
get: function () {
return bloomStrength;
},
set: function (value) {
if (bloomStrength === value) {
return;
}
bloomStrength = value;
if (gameObject._bloom) {
gameObject._bloom.strength = bloomStrength;
}
},
});
Object.defineProperty(gameObject, 'bloomSteps', {
get: function () {
return bloomSteps;
},
set: function (value) {
if (bloomSteps === value) {
return;
}
bloomSteps = value;
if (gameObject._bloom) {
gameObject._bloom.steps = bloomSteps;
}
},
});
gameObject.bloomColor = null;
AddClearEffectCallback(gameObject, 'bloomColor');
return gameObject;
};
var AddBlurProperties = function (gameObject) {
// Don't attach properties again
if (HasProperty(gameObject, 'blurColor')) {
return gameObject;
}
var filterList = GetFilterList(gameObject);
var blurColor,
blurQuality = 0,
blurX = 1,
blurY = 1,
blurStrength = 1,
blurSteps = 4;
Object.defineProperty(gameObject, 'blurColor', {
get: function () {
return blurColor;
},
set: function (value) {
if (blurColor === value) {
return;
}
blurColor = value;
if ((blurColor === null) || (blurColor === false)) {
if (gameObject._blur) {
filterList.remove(gameObject._blur);
gameObject._blur = undefined;
}
} else {
if (!gameObject._blur) {
gameObject._blur = filterList.addBlur(blurQuality, blurX, blurY, blurStrength, blurColor, blurSteps);
}
gameObject._blur.color = blurColor;
}
},
});
Object.defineProperty(gameObject, 'blurQuality', {
get: function () {
return blurQuality;
},
set: function (value) {
if (blurQuality === value) {
return;
}
blurQuality = value;
if (gameObject._blur) {
gameObject._blur.quality = blurQuality;
}
},
});
Object.defineProperty(gameObject, 'blurX', {
get: function () {
return blurX;
},
set: function (value) {
if (blurX === value) {
return;
}
blurX = value;
if (gameObject._blur) {
gameObject._blur.x = blurX;
}
},
});
Object.defineProperty(gameObject, 'blurY', {
get: function () {
return blurY;
},
set: function (value) {
if (blurY === value) {
return;
}
blurY = value;
if (gameObject._blur) {
gameObject._blur.y = blurY;
}
},
});
Object.defineProperty(gameObject, 'blurStrength', {
get: function () {
return blurStrength;
},
set: function (value) {
if (blurStrength === value) {
return;
}
blurStrength = value;
if (gameObject._blur) {
gameObject._blur.strength = blurStrength;
}
},
});
Object.defineProperty(gameObject, 'blurSteps', {
get: function () {
return blurSteps;
},
set: function (value) {
if (blurSteps === value) {
return;
}
blurSteps = value;
if (gameObject._blur) {
gameObject._blur.steps = blurSteps;
}
},
});
gameObject.blurColor = null;
AddClearEffectCallback(gameObject, 'blurColor');
return gameObject;
};
var AddBokehProperties = function (gameObject) {
// Don't attach properties again
if (HasProperty(gameObject, 'bokehRadius')) {
return gameObject;
}
var filterList = GetFilterList(gameObject);
var bokehRadius,
bokehAmount = 1,
bokehContrast = 0.2;
Object.defineProperty(gameObject, 'bokehRadius', {
get: function () {
return bokehRadius;
},
set: function (value) {
if (bokehRadius === value) {
return;
}
bokehRadius = value;
if ((bokehRadius === null) || (bokehRadius === false)) {
if (gameObject._bokeh) {
filterList.remove(gameObject._bokeh);
gameObject._bokeh = undefined;
}
} else {
if (!gameObject._bokeh) {
gameObject._bokeh = filterList.addBokeh(bokehRadius, bokehAmount, bokehContrast);
}
gameObject._bokeh.radius = bokehRadius;
}
},
});
Object.defineProperty(gameObject, 'bokehAmount', {
get: function () {
return bokehAmount;
},
set: function (value) {
if (bokehAmount === value) {
return;
}
bokehAmount = value;
if (gameObject._bokeh) {
gameObject._bokeh.amount = bokehAmount;
}
},
});
Object.defineProperty(gameObject, 'bokehContrast', {
get: function () {
return bokehContrast;
},
set: function (value) {
if (bokehContrast === value) {
return;
}
bokehContrast = value;
if (gameObject._bokeh) {
gameObject._bokeh.contrast = bokehContrast;
}
},
});
gameObject.bokehRadius = null;
AddClearEffectCallback(gameObject, 'bokehRadius');
return gameObject;
};
var AddBrightnessProperties = function (gameObject) {
AddColorMatrixEffectPropertiesBase(gameObject, 'brightness', 1);
return gameObject;
};
var AddBrownProperties = function (gameObject) {
AddColorMatrixEffectPropertiesBase(gameObject, 'brown');
return gameObject;
};
const FilterName$4 = 'FilterP3Circle';
// Built-in fx in phaser3
const frag$4 = `\
#pragma phaserTemplate(shaderName)
#ifdef GL_FRAGMENT_PRECISION_HIGH
#define highmedp highp
#else
#define highmedp mediump
#endif
precision highmedp float;
// Scene buffer
uniform sampler2D uMainSampler;
varying vec2 outTexCoord;
// Effect parameters
uniform vec2 texSize;
uniform vec3 color;
uniform vec4 backgroundColor;
uniform vec3 config;
#pragma phaserTemplate(fragmentHeader)
void main (void) {
float thickness = config.x;
float scale = config.y;
float feather = config.z;
vec4 texture = texture2D(uMainSampler, outTexCoord);
vec2 position = (gl_FragCoord.xy / texSize.xy) * 2.0 - 1.0;
float aspectRatio = texSize.x / texSize.y;
position.x *= aspectRatio;
float grad = length(position);
// height > width
float outer = aspectRatio;
float inner = outer - (thickness * 2.0 / texSize.y);
// width > height
if (aspectRatio >= 1.0)
{
float f = 2.0 + (texSize.y / texSize.x);
outer = 1.0;
inner = 1.0 - (thickness * f / texSize.x);
}
outer *= scale;
inner *= scale;
float circle = smoothstep(outer, outer - 0.01, grad);
float ring = circle - smoothstep(inner, inner - feather, grad);
texture = mix(backgroundColor * backgroundColor.a, texture, texture.a);
texture = (texture * (circle - ring));
gl_FragColor = vec4(texture.rgb + (ring * color), texture.a);
}
`;
class CircleFilter extends Phaser.Renderer.WebGL.RenderNodes.BaseFilterShader {
static FilterName = FilterName$4;
constructor(manager) {
super(FilterName$4, manager, null, frag$4);
}
// This method sets up the uniforms for the shader.
setupUniforms(controller, drawingContext) {
const programManager = this.programManager;
programManager.setUniform('texSize', [drawingContext.width, drawingContext.height]);
programManage