983 lines
31 KiB
JavaScript
983 lines
31 KiB
JavaScript
//=============================================================================
|
|
// TRP_ParticleMZ_SubEmitter.js
|
|
//=============================================================================
|
|
/* このソフトウェアは正規に購入したユーザーのみが利用規約に従って使用することができます。
|
|
また、このソフトウェアはMITライセンス、ならびにApache 2.0ライセンスで配布されている製作物が含まれています。
|
|
http://www.opensource.org/licenses/mit-license
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
*/
|
|
|
|
//=============================================================================
|
|
/*:
|
|
* @target MZ
|
|
* @plugindesc サブエミッター機能の有効化
|
|
* @author Thirop
|
|
* @base TRP_ParticleMZ
|
|
* @orderAfter TRP_ParticleMZ
|
|
* @help
|
|
* 【更新履歴】
|
|
* 1.21 2022/05/02 制御文字が反映されない不具合の修正
|
|
* 1.13 2021/10/27 慣性が正しく働かない不具合修正
|
|
* 1.09 2021/08/18 本体設定「キャッシュ設定(β)」に対応
|
|
* 1.08 2021/06/30 Safari/iOSで生じる起動時エラー修正
|
|
* 1.00 2021/04/10 初版。
|
|
*
|
|
* @command set
|
|
* @text set/サブエミッターのセット
|
|
* @desc サブエミッターをセット（親エミッターの再生直後に実行すること）
|
|
*
|
|
* @arg id
|
|
* @text 親エミッターID
|
|
* @desc 対象とする(再生中の)親エミッターID
|
|
*
|
|
* @arg name
|
|
* @text 設定名
|
|
* @desc サブエミッターとして再生する設定名
|
|
*
|
|
* @arg timing
|
|
* @text 開始タイミング
|
|
* @desc 射出を開始するタイミング(0~1)
|
|
* @default 0
|
|
*
|
|
* @arg endTiming
|
|
* @text 終了タイミング
|
|
* @desc 射出を終了するタイミング(0~1)、-1で無効。emitterLifetimeか早いほうが優先。
|
|
* @default -1
|
|
*
|
|
* @arg speedRate
|
|
* @text 慣性速度
|
|
* @desc 慣性の影響度合い(0~1で0%~100%)
|
|
* @default 0
|
|
*
|
|
* @arg inheritAngle
|
|
* @text 角度の継承
|
|
* @desc 角度の継承モード。0で親パーティクルの角度の影響なし、1で影響あり。
|
|
* @default 0
|
|
*
|
|
* @arg inheritScale
|
|
* @text 拡大率乗数の継承
|
|
* @desc 拡大率乗数の継承モード。0で親パーティクルのminimumScaleMultiplierの影響なし、1で影響あり。
|
|
* @default 0
|
|
*
|
|
* @arg delay
|
|
* @text _ディレイ
|
|
* @desc 1以上とすると、指定フレーム後にコマンドを実効。
|
|
* @default 0
|
|
* @type number
|
|
* @min 0
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
//PRAGMA_END: subEmitterHeader
|
|
//PRAGMA: englishHeader
|
|
//PRAGMA_END: englishHeader
|
|
|
|
(function () {
|
|
"use strict";
|
|
|
|
//PRAGMA: subEmitterRegisterCommands
|
|
(() => {
|
|
var pluginName = "TRP_ParticleMZ_SubEmitter";
|
|
var command = "set";
|
|
PluginManager.registerCommand(pluginName, command, function (args) {
|
|
//this > interpreter
|
|
var argsArr = Object.values(args);
|
|
var delay = Number(argsArr.pop()) || 0;
|
|
var pCommand = command;
|
|
|
|
argsArr.unshift(pCommand);
|
|
argsArr.unshift("sub");
|
|
|
|
var eventId = this.eventId();
|
|
if (delay > 0) {
|
|
$gameScreen._particle.reservePluginCommand(
|
|
delay,
|
|
this,
|
|
argsArr,
|
|
eventId
|
|
);
|
|
} else {
|
|
$gameScreen._particle.pluginCommand(this, argsArr, eventId);
|
|
}
|
|
});
|
|
})();
|
|
//PRAGMA_END: subEmitterRegisterCommands
|
|
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
/* global Reflect, Promise */
|
|
var extendStatics = function (d, b) {
|
|
extendStatics =
|
|
Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array &&
|
|
function (d, b) {
|
|
d.__proto__ = b;
|
|
}) ||
|
|
function (d, b) {
|
|
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
|
};
|
|
return extendStatics(d, b);
|
|
};
|
|
function __extends(d, b) {
|
|
extendStatics(d, b);
|
|
function __() {
|
|
this.constructor = d;
|
|
}
|
|
d.prototype =
|
|
b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
|
|
}
|
|
/***************************************************************************** */
|
|
|
|
//PRAGMA: subEmitterPluginSetting
|
|
var baseParameters = PluginManager.parameters("TRP_ParticleMZ");
|
|
//PRAGMA_END: subEmitterPluginSetting
|
|
|
|
var LC = TRP_Localize.localize.bind(TRP_Localize, "parSe");
|
|
|
|
var _Game_Particle_particleData = Game_Particle.prototype.particleData;
|
|
Game_Particle.prototype.particleData = function (
|
|
eventId,
|
|
id,
|
|
target,
|
|
name,
|
|
z,
|
|
x,
|
|
y,
|
|
image
|
|
) {
|
|
var data = _Game_Particle_particleData.apply(this, arguments);
|
|
if (data.subs) {
|
|
data.subs = null;
|
|
}
|
|
return data;
|
|
};
|
|
|
|
var _Game_Particle_pluginCommand = Game_Particle.prototype.pluginCommand;
|
|
Game_Particle.prototype.pluginCommand = function (
|
|
interpreter,
|
|
args,
|
|
eventId
|
|
) {
|
|
var sub = args[0].toLowerCase();
|
|
if (sub === "sub") {
|
|
this.processSubEmitterCommand(interpreter, args, eventId);
|
|
} else {
|
|
_Game_Particle_pluginCommand.call(this, interpreter, args, eventId);
|
|
}
|
|
};
|
|
|
|
Game_Particle.prototype.processSubEmitterCommand = function (
|
|
interpreter,
|
|
args,
|
|
eventId
|
|
) {
|
|
this.convertEscapeCharacters(args);
|
|
|
|
var main = args.shift();
|
|
var sub = args.shift().toLowerCase();
|
|
|
|
if (!isNaN(eventId)) {
|
|
this.processArgsEventId(args, eventId);
|
|
}
|
|
|
|
if (sub === "set" || sub === "play" || sub === "edit") {
|
|
if (sub === "set" || sub === "play") {
|
|
Game_Particle.prototype.particleSubEmitterSet.apply(this, args);
|
|
} else if (sub === "edit") {
|
|
if (
|
|
Game_Particle.prototype.particleSubEmitterEdit.apply(this, args) &&
|
|
interpreter
|
|
) {
|
|
interpreter.wait(1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Game_Particle.prototype.particleSubEmitterSet = function (
|
|
id,
|
|
name,
|
|
timing = 0,
|
|
endTiming = -1,
|
|
speedRate = 0,
|
|
inheritAngle = 0,
|
|
inheritScale = 0
|
|
) {
|
|
var data = this.dataWithId(id);
|
|
if (!data) {
|
|
return;
|
|
}
|
|
var subEmitters = data.subs;
|
|
if (!subEmitters) {
|
|
subEmitters = data.subs = [];
|
|
}
|
|
|
|
var length = subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var sb = subEmitters[i];
|
|
if (sb[0] === name) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
subEmitters.push([
|
|
name,
|
|
Number(timing),
|
|
Number(endTiming),
|
|
Number(speedRate),
|
|
Number(inheritAngle),
|
|
Number(inheritScale),
|
|
]);
|
|
};
|
|
|
|
Game_Particle.SUB_EMITTER_DEFAULT_DATA = null;
|
|
Game_Particle.prototype.particleSubEmitterEdit = function (
|
|
id,
|
|
name,
|
|
timing = 0,
|
|
endTiming = -1,
|
|
speedRate = 0,
|
|
inheritAngle = 0,
|
|
inheritScale = 0
|
|
) {
|
|
//ensure config data exists
|
|
if (!$dataTrpParticles[name] && !$dataTrpParticlePreset[name]) {
|
|
if (!Game_Particle.SUB_EMITTER_DEFAULT_DATA) {
|
|
Game_Particle.SUB_EMITTER_DEFAULT_DATA = JsonEx.makeDeepCopy(
|
|
ParticleEditor.DEFAULT_DATA || {}
|
|
);
|
|
Game_Particle.SUB_EMITTER_DEFAULT_DATA.frequency = 0.1;
|
|
}
|
|
$dataTrpParticles[name] = JsonEx.makeDeepCopy(
|
|
Game_Particle.SUB_EMITTER_DEFAULT_DATA
|
|
);
|
|
}
|
|
this.particleSubEmitterSet.apply(this, arguments);
|
|
|
|
id = id + Game_Particle.SUB_EMITTER_DEV_SUFFIX + name;
|
|
var exData = {
|
|
timing: timing,
|
|
endTiming: endTiming,
|
|
speedRate: speedRate,
|
|
inheritAngle: inheritAngle,
|
|
inheritScale: inheritScale,
|
|
};
|
|
this._particleEditWithExData(exData, 0, "", id);
|
|
};
|
|
|
|
Game_Particle.SUB_EMITTER_DEV_SUFFIX = "/SUB:";
|
|
|
|
var _Game_Particle_idWithSuffix = Game_Particle.prototype.idWithSuffix;
|
|
Game_Particle.prototype.idWithSuffix = function (id) {
|
|
if (this._suffix && id.contains(Game_Particle.SUB_EMITTER_DEV_SUFFIX)) {
|
|
var args = id.split(Game_Particle.SUB_EMITTER_DEV_SUFFIX);
|
|
var main = args[0];
|
|
var sub = args[1];
|
|
|
|
main = _Game_Particle_idWithSuffix.call(this, main);
|
|
return main + Game_Particle.SUB_EMITTER_DEV_SUFFIX + sub;
|
|
} else {
|
|
return _Game_Particle_idWithSuffix.call(this, id);
|
|
}
|
|
};
|
|
|
|
//=============================================================================
|
|
// ParticleEmitter
|
|
//=============================================================================
|
|
var _ParticleEmitter_setupBitmaps = ParticleEmitter.prototype.setupBitmaps;
|
|
ParticleEmitter.prototype.setupBitmaps = function (image, bitmaps) {
|
|
_ParticleEmitter_setupBitmaps.call(this, image, bitmaps);
|
|
|
|
this._setupSubEmitterBitmaps = true;
|
|
if (this._data.subs) {
|
|
this.setupSubEmitters(image, bitmaps, this._data.subs);
|
|
} else {
|
|
this.tryStart(image, bitmaps);
|
|
}
|
|
};
|
|
|
|
var _ParticleEmitter_initMembers = ParticleEmitter.prototype.initMembers;
|
|
ParticleEmitter.prototype.initMembers = function () {
|
|
_ParticleEmitter_initMembers.call(this);
|
|
|
|
this._setupSubEmitterBitmaps = false;
|
|
this._subData = null;
|
|
this._subNames = null;
|
|
this._subBitmaps = null;
|
|
};
|
|
|
|
ParticleEmitter.prototype.setupSubEmitters = function (
|
|
image,
|
|
mainBitmaps,
|
|
subData
|
|
) {
|
|
this._subData = subData;
|
|
this._subNames = [];
|
|
var bitmaps = (this._subBitmaps = []);
|
|
|
|
var length = subData.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var data = subData[i];
|
|
var name = data[0];
|
|
var config = Game_Particle.configDataWithName(name);
|
|
Array.prototype.push.apply(
|
|
bitmaps,
|
|
this.bitmapsWithImage(config.image || baseParameters.defaultImage)
|
|
);
|
|
this._subNames.push(name);
|
|
}
|
|
|
|
var length = bitmaps.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
bitmaps[i].addLoadListener(
|
|
ParticleEmitter.prototype.tryStart.bind(this, image, mainBitmaps)
|
|
);
|
|
}
|
|
};
|
|
|
|
var _ParticleEmitter_tryStart = ParticleEmitter.prototype.tryStart;
|
|
ParticleEmitter.prototype.tryStart = function (image, bitmaps) {
|
|
if (this._started) return;
|
|
if (!this._setupSubEmitterBitmaps) {
|
|
return;
|
|
}
|
|
if (this._subBitmaps) {
|
|
for (const bitmap of this._subBitmaps) {
|
|
if (!bitmap.isReady()) {
|
|
return false;
|
|
}
|
|
}
|
|
this._subBitmaps = null;
|
|
}
|
|
return _ParticleEmitter_tryStart.call(this, image, bitmaps);
|
|
};
|
|
|
|
var _ParticleEmitter_start = ParticleEmitter.prototype.start;
|
|
ParticleEmitter.prototype.start = function (image, bitmaps) {
|
|
_ParticleEmitter_start.call(this, image, bitmaps);
|
|
|
|
if (this._subData) {
|
|
var emitter = this._emitter;
|
|
var container = this._container;
|
|
for (const data of this._subData) {
|
|
this.setSubEmitter(emitter, container, data);
|
|
}
|
|
}
|
|
};
|
|
ParticleEmitter.prototype.setSubEmitter = function (
|
|
emitter,
|
|
container,
|
|
data
|
|
) {
|
|
var name = data[0];
|
|
var timing = data[1] || 0;
|
|
var endTiming = data.length >= 3 ? data[2] || 0 : -1;
|
|
var speedRate = data[3] || 0;
|
|
var inheritAngle = data[4] || 0;
|
|
var inheritScale = data[5] || 0;
|
|
var config = Game_Particle.configDataWithName(name);
|
|
|
|
var image = config.image || baseParameters.defaultImage;
|
|
var bitmaps = this.bitmapsWithImage(image);
|
|
var textures = this._texturesWithBitmaps(image, bitmaps);
|
|
emitter.setSubEmitter(
|
|
container,
|
|
textures,
|
|
config,
|
|
timing,
|
|
endTiming,
|
|
speedRate,
|
|
inheritAngle,
|
|
inheritScale
|
|
);
|
|
};
|
|
|
|
ParticleEmitter.prototype.particleConstructor = function () {
|
|
return this._subData ? TRP_ParticleEx : TRP_Particle;
|
|
};
|
|
ParticleEmitter.prototype.emitterConstructor = function () {
|
|
return this._subData ? TRP_EmitterEx : TRP_Emitter;
|
|
};
|
|
ParticleEmitter.prototype.subEmitter = function (name) {
|
|
return this._emitter._subEmitters
|
|
? this._emitter._subEmitters[this._subNames.indexOf(name)]
|
|
: null;
|
|
};
|
|
|
|
var _ParticleEmitter_loopParticles = ParticleEmitter.prototype.loopParticles;
|
|
ParticleEmitter.prototype.loopParticles = function (loopX, loopY) {
|
|
_ParticleEmitter_loopParticles.call(this, loopX, loopY, this._emitter);
|
|
|
|
if (this._subEmitters) {
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
_ParticleEmitter_loopParticles.call(
|
|
this,
|
|
loopX,
|
|
loopY,
|
|
this._subEmitters[i]
|
|
);
|
|
}
|
|
}
|
|
};
|
|
|
|
var _ParticleEmitter_cleanup = ParticleEmitter.prototype.cleanup;
|
|
ParticleEmitter.prototype.cleanup = function () {
|
|
_ParticleEmitter_cleanup.call(this);
|
|
|
|
if (this._emitter instanceof TRP_EmitterEx) {
|
|
this._emitter.cleanupSubEmitters();
|
|
}
|
|
};
|
|
|
|
//=============================================================================
|
|
// TRP_EmitterEx
|
|
//=============================================================================
|
|
var TRP_Emitter = ParticleEmitter.TRP_Emitter;
|
|
var Emitter = PIXI.particles.Emitter;
|
|
|
|
var TRP_EmitterEx = /** @class */ (function (_super) {
|
|
__extends(TRP_EmitterEx, _super);
|
|
|
|
var utils = PIXI.particles.ParticleUtils;
|
|
function TRP_EmitterEx(particleParent, particleImages, config) {
|
|
var _this =
|
|
_super.call(this, particleParent, particleImages, config) || this;
|
|
_this._subEmitters = [];
|
|
return _this;
|
|
}
|
|
|
|
TRP_EmitterEx.prototype.destroy = function (force) {
|
|
if (!force && this.particleTotalCount() > 0) return;
|
|
|
|
_super.prototype.destroy.call(this);
|
|
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
this._subEmitters[i].destroy();
|
|
}
|
|
this._subEmitters.length = 0;
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.cleanupSubEmitters = function () {
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var sub = this._subEmitters[i];
|
|
sub.cleanup();
|
|
}
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.particleTotalCount = function () {
|
|
var count = this.particleCount;
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
count += this._subEmitters[i].particleCount;
|
|
}
|
|
return count;
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.update = function (delta) {
|
|
_super.prototype.update.call(this, delta);
|
|
|
|
if (!this._parent) return;
|
|
if (this._subEmitters) {
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
this._subEmitters[i].update(delta);
|
|
}
|
|
}
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.setSubEmitter = function (
|
|
container,
|
|
textures,
|
|
config,
|
|
timing,
|
|
endTiming,
|
|
speedRate,
|
|
inheritAngle,
|
|
inheritScale
|
|
) {
|
|
var emitter = new TRP_SubEmitter(
|
|
container,
|
|
textures,
|
|
config,
|
|
timing,
|
|
endTiming,
|
|
speedRate,
|
|
inheritAngle,
|
|
inheritScale
|
|
);
|
|
this._subEmitters.push(emitter);
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.applyAdditionalProperties = function (p) {
|
|
TRP_Emitter.prototype.applyAdditionalProperties.call(this, p);
|
|
|
|
p.subEmitters = this._subEmitters;
|
|
if (p.subEmitters) {
|
|
var emitters = p.subEmitters;
|
|
var length = emitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
this.pushSubEmitterData(p, i);
|
|
}
|
|
}
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.pushSubEmitterData = function (p, i) {
|
|
var data = p.subEmitterData[i];
|
|
if (!data) {
|
|
data = {};
|
|
p.subEmitterData[i] = data;
|
|
|
|
data._prevEmitterPos = new PIXI.Point(p.x, p.y);
|
|
} else {
|
|
data._prevEmitterPos.x = p.x;
|
|
data._prevEmitterPos.y = p.y;
|
|
}
|
|
data._emit = false;
|
|
data._spawnTimer = 0;
|
|
data._emitterLife = 0;
|
|
data._prevPosIsValid = false;
|
|
data._spawn = false;
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.applyCapacityLimit = function () {
|
|
var naturalCapacity = this.naturalCapacity(
|
|
this._originalFrequency,
|
|
this._originalParticlesPerWave
|
|
);
|
|
var subCapacity = this.subEmittersCapacity();
|
|
|
|
var mainRate = Math.pow(
|
|
this._capacityRate,
|
|
naturalCapacity / (naturalCapacity + subCapacity || 1)
|
|
);
|
|
var subRate = this._capacityRate / (mainRate || 1);
|
|
|
|
//main limit
|
|
var target = naturalCapacity * mainRate;
|
|
this.maxParticles = target;
|
|
if (this.particlesPerWave > 1) {
|
|
this.particlesPerWave =
|
|
Math.ceil(
|
|
Math.min(
|
|
this._originalParticlesPerWave,
|
|
this._originalParticlesPerWave * (target / naturalCapacity)
|
|
)
|
|
) || 1;
|
|
naturalCapacity = this.naturalCapacity(
|
|
this._originalFrequency,
|
|
this.particlesPerWave
|
|
);
|
|
}
|
|
this.frequency = Math.max(
|
|
this._originalFrequency,
|
|
this._originalFrequency / (target / naturalCapacity)
|
|
);
|
|
|
|
//sub limit
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var sub = this._subEmitters[i];
|
|
sub.capacityRate = subRate;
|
|
sub.maxParticles = sub._originalMaxParticles * subRate;
|
|
}
|
|
};
|
|
|
|
TRP_EmitterEx.prototype.particleCapacity = function () {
|
|
var capacity = _super.prototype.particleCapacity.call(this);
|
|
var subCapacity = this.subEmittersCapacity();
|
|
return capacity * subCapacity;
|
|
};
|
|
TRP_EmitterEx.prototype.subEmittersCapacity = function () {
|
|
var subCapacity = 1;
|
|
var length = this._subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
subCapacity += this._subEmitters[i].particleCapacity();
|
|
}
|
|
return subCapacity;
|
|
};
|
|
|
|
return TRP_EmitterEx;
|
|
})(TRP_Emitter);
|
|
ParticleEmitter.TRP_EmitterEx = TRP_EmitterEx;
|
|
|
|
//=============================================================================
|
|
// TRP_SubEmitter
|
|
//=============================================================================
|
|
var TRP_SubEmitter = /** @class */ (function (_super) {
|
|
__extends(TRP_SubEmitter, _super);
|
|
|
|
var utils = PIXI.particles.ParticleUtils;
|
|
function TRP_SubEmitter(
|
|
particleParent,
|
|
particleImages,
|
|
config,
|
|
timing = 0,
|
|
endTiming = -1,
|
|
speedRate = 0,
|
|
inheritAngle = 0,
|
|
inheritScale = 0
|
|
) {
|
|
var _this =
|
|
TRP_Emitter.call(this, particleParent, particleImages, config) || this;
|
|
_this._particleConstructor = TRP_Particle;
|
|
|
|
_this.timing = timing;
|
|
_this.endTiming = endTiming;
|
|
_this.speedRate = speedRate;
|
|
_this.inheritAngle = inheritAngle;
|
|
_this.inheritScale = inheritScale;
|
|
|
|
return _this;
|
|
}
|
|
|
|
TRP_SubEmitter.prototype.update = function (delta) {
|
|
if (this._autoUpdate) {
|
|
delta = delta / pixi.settings.TARGET_FPMS / 1000;
|
|
}
|
|
if (!this._parent) return;
|
|
|
|
var i, particle, next;
|
|
for (particle = this._activeParticlesFirst; particle; particle = next) {
|
|
next = particle.next;
|
|
particle.update(delta);
|
|
}
|
|
};
|
|
|
|
TRP_SubEmitter.prototype.updateParticleEmitter = function (
|
|
ep,
|
|
lerp,
|
|
delta,
|
|
data
|
|
) {
|
|
//data ~ time,
|
|
//ep : emitter particle
|
|
if (!data._emit) {
|
|
if (!data._spawn && lerp >= this.timing) {
|
|
data._emit = true;
|
|
data._spawn = true;
|
|
data._emitterLife = this.emitterLifetime;
|
|
} else {
|
|
return;
|
|
}
|
|
} else if (this.endTiming >= 0 && lerp >= this.endTiming) {
|
|
data._spawnTimer = 0;
|
|
data._emitterLife = 0;
|
|
data._emit = false;
|
|
return;
|
|
}
|
|
|
|
if (!this._parent) return;
|
|
|
|
if (this._autoUpdate) {
|
|
delta = delta / pixi.settings.TARGET_FPMS / 1000;
|
|
}
|
|
|
|
//update existing particles
|
|
var prevX, prevY;
|
|
//if the previous position is valid, store these for later interpolation
|
|
if (data._prevPosIsValid) {
|
|
prevX = data._prevEmitterPos.x;
|
|
prevY = data._prevEmitterPos.y;
|
|
}
|
|
//store current position of the emitter as local variables
|
|
var curX = ep.x + this.spawnPos.x;
|
|
var curY = ep.y + this.spawnPos.y;
|
|
var posChanged =
|
|
data._prevPosIsValid && (prevX !== curX || prevY !== curY);
|
|
|
|
//spawn new particles
|
|
if (this._emit) {
|
|
//decrease spawn timer
|
|
data._spawnTimer -= delta < 0 ? 0 : delta;
|
|
//while _spawnTimer < 0, we have particles to spawn
|
|
while (data._spawnTimer <= 0) {
|
|
//determine if the emitter should stop spawning
|
|
if (data._emitterLife > 0) {
|
|
data._emitterLife -= this._frequency;
|
|
if (data._emitterLife <= 0) {
|
|
data._spawnTimer = 0;
|
|
data._emitterLife = 0;
|
|
data._emit = false;
|
|
break;
|
|
}
|
|
}
|
|
//determine if we have hit the particle limit
|
|
if (this.particleCount >= this.maxParticles) {
|
|
data._spawnTimer += this._frequency;
|
|
continue;
|
|
}
|
|
//determine the particle lifetime
|
|
var lifetime = void 0;
|
|
if (this.minLifetime == this.maxLifetime) lifetime = this.minLifetime;
|
|
else
|
|
lifetime =
|
|
Math.random() * (this.maxLifetime - this.minLifetime) +
|
|
this.minLifetime;
|
|
//only make the particle if it wouldn't immediately destroy itself
|
|
if (-data._spawnTimer < lifetime) {
|
|
//If the position has changed and this isn't the first spawn,
|
|
//interpolate the spawn position
|
|
var emitPosX = void 0,
|
|
emitPosY = void 0;
|
|
if (data._prevPosIsValid && posChanged) {
|
|
//1 - _spawnTimer / delta, but _spawnTimer is negative
|
|
var lerp = 1 + data._spawnTimer / delta;
|
|
emitPosX = (curX - prevX) * lerp + prevX;
|
|
emitPosY = (curY - prevY) * lerp + prevY;
|
|
} //otherwise just set to the spawn position
|
|
else {
|
|
emitPosX = curX;
|
|
emitPosY = curY;
|
|
}
|
|
//create enough particles to fill the wave (non-burst types have a wave of 1)
|
|
var i = 0;
|
|
for (
|
|
var len = Math.min(
|
|
this.particlesPerWave,
|
|
this.maxParticles - this.particleCount
|
|
);
|
|
i < len;
|
|
++i
|
|
) {
|
|
//see if we actually spawn one
|
|
if (this.spawnChance < 1 && Math.random() >= this.spawnChance)
|
|
continue;
|
|
//create particle
|
|
var p = void 0;
|
|
if (this._poolFirst) {
|
|
p = this._poolFirst;
|
|
this._poolFirst = this._poolFirst.next;
|
|
p.next = null;
|
|
} else {
|
|
p = new this.particleConstructor(this);
|
|
}
|
|
//set a random texture if we have more than one
|
|
if (this.particleImages.length > 1) {
|
|
// if using ordered art
|
|
if (this._currentImageIndex !== -1) {
|
|
// get current art index, then increment for the next particle
|
|
p.applyArt(this.particleImages[this._currentImageIndex++]);
|
|
// loop around if needed
|
|
if (
|
|
this._currentImageIndex < 0 ||
|
|
this._currentImageIndex >= this.particleImages.length
|
|
) {
|
|
this._currentImageIndex = 0;
|
|
}
|
|
}
|
|
// otherwise grab a random one
|
|
else {
|
|
p.applyArt(
|
|
this.particleImages[
|
|
Math.floor(Math.random() * this.particleImages.length)
|
|
]
|
|
);
|
|
}
|
|
} else {
|
|
//if they are actually the same texture, a standard particle
|
|
//will quit early from the texture setting in setTexture().
|
|
p.applyArt(this.particleImages[0]);
|
|
}
|
|
//set up the start and end values
|
|
p.alphaList.reset(this.startAlpha);
|
|
p.speedList.reset(this.startSpeed);
|
|
if (this.minimumSpeedMultiplier != 1) {
|
|
p.speedMultiplier =
|
|
Math.random() * (1 - this.minimumSpeedMultiplier) +
|
|
this.minimumSpeedMultiplier;
|
|
}
|
|
p.acceleration.x = this.acceleration.x;
|
|
p.acceleration.y = this.acceleration.y;
|
|
p.maxSpeed = this.maxSpeed;
|
|
if (this.minimumScaleMultiplier != 1) {
|
|
p.scaleMultiplier =
|
|
Math.random() * (1 - this.minimumScaleMultiplier) +
|
|
this.minimumScaleMultiplier;
|
|
}
|
|
p.scaleList.reset(this.startScale);
|
|
p.colorList.reset(this.startColor);
|
|
//randomize the rotation speed
|
|
if (this.minRotationSpeed == this.maxRotationSpeed)
|
|
p.rotationSpeed = this.minRotationSpeed;
|
|
else
|
|
p.rotationSpeed =
|
|
Math.random() *
|
|
(this.maxRotationSpeed - this.minRotationSpeed) +
|
|
this.minRotationSpeed;
|
|
p.rotationAcceleration = this.rotationAcceleration;
|
|
p.noRotation = this.noRotation;
|
|
//set up the lifetime
|
|
p.maxLife = lifetime;
|
|
//set the blend mode
|
|
p.blendMode = this.particleBlendMode;
|
|
//set the custom ease, if any
|
|
p.ease = this.customEase;
|
|
//set the extra data, if any
|
|
p.extraData = this.extraData;
|
|
|
|
//set additional properties to particle
|
|
this.applyAdditionalProperties(p);
|
|
//call the proper function to handle rotation and position of particle
|
|
this._spawnFunc(p, emitPosX, emitPosY, i);
|
|
|
|
if (this.inheritScale > 0) {
|
|
p.scaleMultiplier *= ep.scaleMultiplier;
|
|
}
|
|
|
|
//initialize particle
|
|
p.init();
|
|
|
|
//inertia
|
|
p.iVelocity.x = this.speedRate * ep.velocity.x;
|
|
p.iVelocity.y = this.speedRate * ep.velocity.y;
|
|
p._doInertia = !!(p.iVelocity.x || p.iVelocity.y);
|
|
|
|
//inheritAngle
|
|
if (this.inheritAngle > 0) {
|
|
var v1Rotation = Math.atan2(ep.velocity.y, ep.velocity.x);
|
|
utils.rotatePoint(v1Rotation / utils.DEG_TO_RADS, p.velocity);
|
|
p.rotation += v1Rotation;
|
|
}
|
|
|
|
//update the particle by the time passed, so the particles are spread out properly
|
|
p.update(-data._spawnTimer); //we want a positive delta, because a negative delta messes things up
|
|
//add the particle to the display list
|
|
if (!p.parent) {
|
|
if (this.addAtBack) this._parent.addChildAt(p, 0);
|
|
else this._parent.addChild(p);
|
|
} else {
|
|
//kind of hacky, but performance friendly
|
|
//shuffle children to correct place
|
|
var children = this._parent.children;
|
|
//avoid using splice if possible
|
|
if (children[0] == p) children.shift();
|
|
else if (children[children.length - 1] == p) children.pop();
|
|
else {
|
|
var index = children.indexOf(p);
|
|
children.splice(index, 1);
|
|
}
|
|
if (this.addAtBack) children.unshift(p);
|
|
else children.push(p);
|
|
}
|
|
//add particle to list of active particles
|
|
if (this._activeParticlesLast) {
|
|
this._activeParticlesLast.next = p;
|
|
p.prev = this._activeParticlesLast;
|
|
this._activeParticlesLast = p;
|
|
} else {
|
|
this._activeParticlesLast = this._activeParticlesFirst = p;
|
|
}
|
|
++this.particleCount;
|
|
}
|
|
}
|
|
//increase timer and continue on to any other particles that need to be created
|
|
data._spawnTimer += this._frequency;
|
|
}
|
|
//if the position changed before this update, then keep track of that
|
|
|
|
data._prevEmitterPos.x = curX;
|
|
data._prevEmitterPos.y = curY;
|
|
data._prevPosIsValid = true;
|
|
}
|
|
};
|
|
return TRP_SubEmitter;
|
|
})(ParticleEmitter.TRP_Emitter);
|
|
|
|
//=============================================================================
|
|
// TRP_ParticleEx
|
|
//=============================================================================
|
|
var TRP_Particle = ParticleEmitter.TRP_Particle;
|
|
var TRP_ParticleEx = /** @class */ (function (_super) {
|
|
__extends(TRP_ParticleEx, _super);
|
|
|
|
var utils = PIXI.particles.ParticleUtils;
|
|
function TRP_ParticleEx(emitter) {
|
|
var _this = _super.call(this, emitter) || this;
|
|
_this.subEmitters = null;
|
|
_this.subEmitterData = [];
|
|
|
|
return _this;
|
|
}
|
|
|
|
TRP_ParticleEx.prototype.kill = function () {
|
|
var emitters = this.subEmitters;
|
|
var length = emitters ? emitters.length : 0;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var data = this.subEmitterData[i];
|
|
if (!data._spawn || data._emitterLife > 0) {
|
|
return;
|
|
}
|
|
}
|
|
_super.prototype.kill.call(this);
|
|
};
|
|
|
|
TRP_ParticleEx.prototype.update = function (delta) {
|
|
var lerp = _super.prototype.update.call(this, delta);
|
|
if (this._wait > 0) return lerp;
|
|
|
|
var emitters = this.subEmitters;
|
|
var length = emitters ? emitters.length : 0;
|
|
var subLerp = lerp < 0 ? 1 : lerp;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
emitters[i].updateParticleEmitter(
|
|
this,
|
|
subLerp,
|
|
delta,
|
|
this.subEmitterData[i]
|
|
);
|
|
}
|
|
return lerp;
|
|
};
|
|
|
|
return TRP_ParticleEx;
|
|
})(TRP_Particle);
|
|
|
|
/* cache config
|
|
===================================*/
|
|
(function () {
|
|
"use strict";
|
|
if (!baseParameters.useCache || baseParameters.useCache === "false") return;
|
|
|
|
//=============================================================================
|
|
// TRP_Emitter
|
|
//=============================================================================
|
|
var Emitter = PIXI.particles.Emitter;
|
|
var TRP_Emitter = ParticleEmitter.TRP_Emitter;
|
|
var TRP_EmitterEx = ParticleEmitter.TRP_EmitterEx;
|
|
if (TRP_EmitterEx) {
|
|
var _TRP_EmitterEx_applyAdditionalProperties =
|
|
TRP_EmitterEx.prototype.applyAdditionalProperties;
|
|
TRP_EmitterEx.prototype.applyAdditionalProperties = function (p) {
|
|
_TRP_EmitterEx_applyAdditionalProperties.call(this, p);
|
|
|
|
var naturalCapacity = this.naturalCapacity(
|
|
this._originalFrequency,
|
|
this._originalParticlesPerWave
|
|
);
|
|
var rate = naturalCapacity - 1;
|
|
|
|
var subEmitters = this._subEmitters;
|
|
var length = subEmitters.length;
|
|
for (var i = 0; i < length; i = (i + 1) | 0) {
|
|
var emitter = subEmitters[i];
|
|
emitter.preparePoolFromCache(rate);
|
|
}
|
|
};
|
|
}
|
|
})();
|
|
})();
|