mirror of
https://github.com/Ttanasart-pt/Pixel-Composer.git
synced 2024-11-14 06:23:55 +01:00
472 lines
10 KiB
Plaintext
472 lines
10 KiB
Plaintext
enum ANIM_END_ACTION {
|
|
loop,
|
|
pingpong,
|
|
destroy,
|
|
}
|
|
|
|
enum PARTICLE_BLEND_MODE {
|
|
normal,
|
|
alpha,
|
|
additive
|
|
}
|
|
|
|
enum PARTICLE_RENDER_TYPE {
|
|
surface,
|
|
line,
|
|
}
|
|
|
|
function __particleObject() constructor {
|
|
active = false;
|
|
x = 0;
|
|
y = 0;
|
|
|
|
static kill = function() {}
|
|
|
|
static step = function() {}
|
|
|
|
static draw = function() {}
|
|
|
|
}
|
|
|
|
function __part(_node) : __particleObject() constructor {
|
|
seed = irandom(99999);
|
|
node = _node;
|
|
active = false;
|
|
|
|
/////////////////////// Lifespans ///////////////////////
|
|
life = 0;
|
|
life_total = 0;
|
|
life_incr = 0;
|
|
step_int = 0;
|
|
|
|
/////////////////////// Transforms ///////////////////////
|
|
prevx = 0;
|
|
prevy = 0;
|
|
x = 0;
|
|
y = 0;
|
|
speedx = 0;
|
|
speedy = 0;
|
|
turning = 0;
|
|
turnSpd = 0;
|
|
|
|
x_history = [];
|
|
y_history = [];
|
|
|
|
accel = 0;
|
|
spVec = [ 0, 0 ];
|
|
|
|
grav = 0;
|
|
gravDir = -90;
|
|
gravX = 0;
|
|
gravY = 0;
|
|
|
|
scx = 1;
|
|
scy = 1;
|
|
sc_sx = 1;
|
|
sc_sy = 1;
|
|
sct = noone;
|
|
|
|
scx_history = [];
|
|
scy_history = [];
|
|
|
|
rot = 0;
|
|
follow = false;
|
|
rot_s = 0;
|
|
|
|
path = noone;
|
|
pathIndex = 0;
|
|
pathPos = new __vec2();
|
|
pathDiv = noone;
|
|
|
|
/////////////////////// Render ///////////////////////
|
|
render_type = PARTICLE_RENDER_TYPE.surface;
|
|
|
|
surf = noone;
|
|
arr_type = 0;
|
|
|
|
drawx = 0;
|
|
drawy = 0;
|
|
drawrot = 0;
|
|
drawsx = 0;
|
|
drawsy = 0;
|
|
|
|
col = -1;
|
|
blend = c_white;
|
|
alp = 1;
|
|
alp_draw = alp;
|
|
alp_fade = 0;
|
|
currColor = c_white;
|
|
|
|
blend_history = [];
|
|
alp_history = [];
|
|
|
|
anim_speed = 1;
|
|
anim_end = ANIM_END_ACTION.loop;
|
|
|
|
line_draw = 1;
|
|
|
|
/////////////////////// Physics ///////////////////////
|
|
ground = false;
|
|
ground_y = 0;
|
|
ground_bounce = 0;
|
|
ground_friction = 1;
|
|
|
|
trailLife = 0;
|
|
trailActive = false;
|
|
|
|
frame = 0;
|
|
|
|
static reset = function() { #region
|
|
INLINE
|
|
|
|
surf = noone;
|
|
|
|
prevx = undefined;
|
|
prevy = undefined;
|
|
} #endregion
|
|
|
|
static create = function(_surf, _x, _y, _life) { #region
|
|
INLINE
|
|
|
|
active = true;
|
|
surf = _surf;
|
|
x = _x;
|
|
y = _y;
|
|
|
|
drawx = x;
|
|
drawy = y;
|
|
|
|
life_incr = 0;
|
|
life = _life;
|
|
life_total = life;
|
|
if(node.onPartCreate != noone) node.onPartCreate(self);
|
|
|
|
trailLife = 0;
|
|
x_history = array_create(life);
|
|
y_history = array_create(life);
|
|
scx_history = array_create(life);
|
|
scy_history = array_create(life);
|
|
blend_history = array_create(life);
|
|
alp_history = array_create(life);
|
|
} #endregion
|
|
|
|
static setPhysic = function(_sx, _sy, _ac, _g, _gDir, _turn, _turnSpd) { #region
|
|
INLINE
|
|
|
|
speedx = _sx;
|
|
speedy = _sy;
|
|
accel = _ac;
|
|
grav = _g;
|
|
gravDir = _gDir;
|
|
gravX = lengthdir_x(grav, gravDir);
|
|
gravY = lengthdir_y(grav, gravDir);
|
|
|
|
turning = _turn;
|
|
turnSpd = _turnSpd;
|
|
|
|
spVec[0] = point_distance(0, 0, speedx, speedy);
|
|
spVec[1] = point_direction(0, 0, speedx, speedy);
|
|
} #endregion
|
|
|
|
static setWiggle = function(wiggle_maps) { #region
|
|
INLINE
|
|
|
|
wig_psx = wiggle_maps.wig_psx;
|
|
wig_psy = wiggle_maps.wig_psy;
|
|
wig_rot = wiggle_maps.wig_rot;
|
|
wig_scx = wiggle_maps.wig_scx;
|
|
wig_scy = wiggle_maps.wig_scy;
|
|
wig_dir = wiggle_maps.wig_dir;
|
|
} #endregion
|
|
|
|
static setGround = function(_ground, _ground_offset, _ground_bounce, _ground_frict) { #region
|
|
INLINE
|
|
|
|
ground = _ground;
|
|
ground_y = y + _ground_offset;
|
|
ground_bounce = _ground_bounce;
|
|
ground_friction = clamp(1 - _ground_frict, 0, 1);
|
|
} #endregion
|
|
|
|
static setTransform = function(_scx, _scy, _sct, _rot, _rots, _follow) { #region
|
|
INLINE
|
|
|
|
sc_sx = _scx;
|
|
sc_sy = _scy;
|
|
sct = _sct;
|
|
|
|
rot = _rot;
|
|
rot_s = _rots;
|
|
follow = _follow;
|
|
} #endregion
|
|
|
|
static setDraw = function(_col, _blend, _alp, _fade) { #region
|
|
INLINE
|
|
|
|
col = _col;
|
|
blend = _blend;
|
|
alp = _alp;
|
|
alp_draw = _alp;
|
|
alp_fade = _fade;
|
|
} #endregion
|
|
|
|
static setPath = function(_path, _pathDiv) { #region
|
|
INLINE
|
|
|
|
path = _path;
|
|
pathDiv = _pathDiv;
|
|
} #endregion
|
|
|
|
static kill = function(callDestroy = true) { #region
|
|
INLINE
|
|
|
|
active = false;
|
|
if(callDestroy && node.onPartDestroy != noone)
|
|
node.onPartDestroy(self);
|
|
} #endregion
|
|
|
|
static step = function(frame = 0) { #region
|
|
INLINE
|
|
trailLife++;
|
|
|
|
if(!active) return;
|
|
x += speedx;
|
|
self.frame = frame;
|
|
|
|
random_set_seed(seed + life);
|
|
|
|
if(ground && y + speedy > ground_y) {
|
|
y = ground_y;
|
|
speedy = -speedy * ground_bounce;
|
|
|
|
if(abs(speedy) < 0.1)
|
|
speedx *= ground_friction;
|
|
} else
|
|
y += speedy;
|
|
|
|
var dirr = point_direction(0, 0, speedx, speedy);
|
|
var diss = point_distance(0, 0, speedx, speedy);
|
|
diss = max(0, diss + accel);
|
|
|
|
if(speedx != 0 || speedy != 0) {
|
|
dirr += wig_dir.get(seed + life);
|
|
|
|
if(turning != 0) {
|
|
var trn = turning;
|
|
|
|
if(turnSpd > 0) trn = turning * diss * turnSpd;
|
|
else if(turnSpd < 0) trn = turning / diss * turnSpd;
|
|
|
|
dirr += trn
|
|
}
|
|
}
|
|
|
|
speedx = lengthdir_x(diss, dirr) + gravX;
|
|
speedy = lengthdir_y(diss, dirr) + gravY;
|
|
|
|
if(follow) rot = spVec[1];
|
|
else rot += rot_s;
|
|
|
|
if(node.onPartStep != noone && step_int > 0 && safe_mod(life, step_int) == 0)
|
|
node.onPartStep(self);
|
|
|
|
if(life-- < 0) kill();
|
|
|
|
if(prevx != undefined) {
|
|
spVec[0] = point_distance(prevx, prevy, x, y);
|
|
spVec[1] = point_direction(prevx, prevy, x, y);
|
|
}
|
|
|
|
x_history[life_incr] = drawx;
|
|
y_history[life_incr] = drawy;
|
|
life_incr++;
|
|
|
|
prevx = x;
|
|
prevy = y;
|
|
|
|
drawx = x;
|
|
drawy = y;
|
|
drawrot = rot;
|
|
drawsx = sc_sx;
|
|
drawsy = sc_sy;
|
|
|
|
drawx += wig_psx.get(seed + life);
|
|
drawy += wig_psy.get(seed + life);
|
|
drawrot += wig_rot.get(seed + life);
|
|
drawsx += wig_scy.get(seed + life);
|
|
drawsy += wig_scy.get(seed + life);
|
|
} #endregion
|
|
|
|
static draw = function(exact, surf_w, surf_h) { #region
|
|
INLINE
|
|
|
|
if(render_type == PARTICLE_RENDER_TYPE.line) {
|
|
var _trail_ed = min(life_incr, life_total);
|
|
var _trail_st = max(0, trailLife - line_draw);
|
|
var _trail_len = _trail_ed - _trail_st;
|
|
|
|
if(_trail_len <= 0) return;
|
|
}
|
|
|
|
var ss = surf;
|
|
|
|
var lifeRat = 1 - life / life_total;
|
|
var scCurve = sct == noone? 1 : sct.get(lifeRat);
|
|
scx = drawsx * scCurve;
|
|
scy = drawsy * scCurve;
|
|
|
|
if(arr_type == 2 && surf != noone && is_array(surf)) {
|
|
var ind = abs(round((life_total - life) * anim_speed));
|
|
var len = array_length(surf);
|
|
|
|
switch(anim_end) {
|
|
case ANIM_END_ACTION.loop:
|
|
ss = surf[safe_mod(ind, len)];
|
|
break;
|
|
case ANIM_END_ACTION.pingpong:
|
|
var ping = safe_mod(ind, (len - 1) * 2 + 1);
|
|
ss = surf[ping >= len? (len - 1) * 2 - ping : ping];
|
|
break;
|
|
case ANIM_END_ACTION.destroy:
|
|
if(ind >= len) {
|
|
kill();
|
|
return;
|
|
}
|
|
|
|
ss = surf[ind];
|
|
break;
|
|
}
|
|
} else if(arr_type == 3) {
|
|
var _sca = round(min(scx, scy));
|
|
ss = array_safe_get_fast(surf, clamp(_sca, 0, array_length(surf) - 1));
|
|
}
|
|
|
|
var surface = is_instanceof(ss, SurfaceAtlas)? ss.getSurface() : node.surface_cache[$ ss];
|
|
var _useS = is_surface(surface);
|
|
|
|
if(arr_type == 3) {
|
|
scx = 1;
|
|
scy = 1;
|
|
}
|
|
|
|
scx_history[life_incr - 1] = scx;
|
|
scy_history[life_incr - 1] = scy;
|
|
|
|
var _xx, _yy;
|
|
var s_w = (_useS? surface_get_width_safe(surface) : 1) * scx;
|
|
var s_h = (_useS? surface_get_height_safe(surface) : 1) * scy;
|
|
|
|
var _pp = point_rotate(-s_w / 2, -s_h / 2, 0, 0, rot);
|
|
_xx = drawx + _pp[0];
|
|
_yy = drawy + _pp[1];
|
|
|
|
if(path != noone) {
|
|
var _div = pathDiv.get(lifeRat);
|
|
|
|
pathPos = path.getPointRatio(clamp(lifeRat, 0, 0.99), pathIndex, pathPos);
|
|
_xx = _xx * _div + pathPos.x;
|
|
_yy = _yy * _div + pathPos.y;
|
|
}
|
|
|
|
if(exact) {
|
|
_xx = round(_xx);
|
|
_yy = round(_yy);
|
|
}
|
|
|
|
var x0 = _xx - s_w * 1.5;
|
|
var y0 = _yy - s_h * 1.5;
|
|
var x1 = _xx + s_w * 1.5;
|
|
var y1 = _yy + s_h * 1.5;
|
|
|
|
var cc = (col == -1)? c_white : col.eval(lifeRat);
|
|
if(blend != c_white) cc = colorMultiply(blend, cc);
|
|
alp_draw = alp * (alp_fade == noone? 1 : alp_fade.get(lifeRat)) * _color_get_alpha(cc);
|
|
|
|
blend_history[life_incr - 1] = cc;
|
|
alp_history[life_incr - 1] = alp_draw;
|
|
|
|
currColor = cola(cc, alp_draw);
|
|
|
|
if(_useS && (x0 > surf_w || y0 > surf_h || x1 < 0 || y1 < 0))
|
|
return;
|
|
|
|
switch(render_type) {
|
|
case PARTICLE_RENDER_TYPE.surface :
|
|
if(_useS) draw_surface_ext_safe(surface, _xx, _yy, scx, scy, drawrot, cc, alp_draw);
|
|
else {
|
|
var ss = round(min(scx, scy));
|
|
if(round(ss) == 0) return;
|
|
|
|
var _s = shader_current();
|
|
shader_reset();
|
|
|
|
draw_set_color(cc);
|
|
draw_set_alpha(alp_draw);
|
|
dynaSurf_circle_fill(_xx, _yy, exact? round(ss) : ss);
|
|
draw_set_alpha(1);
|
|
|
|
shader_set(_s);
|
|
}
|
|
break;
|
|
|
|
case PARTICLE_RENDER_TYPE.line :
|
|
var _ox, _nx, _oy, _ny;
|
|
var _osx, _nsx, _osy, _nsy;
|
|
var _oc, _nc, _oa, _na;
|
|
|
|
for( var j = 0; j < _trail_len; j++ ) {
|
|
var _index = _trail_st + j;
|
|
|
|
_nx = x_history[ _index];
|
|
_ny = y_history[ _index];
|
|
_nsx = scx_history[ _index];
|
|
_nsy = scy_history[ _index];
|
|
_nc = blend_history[_index];
|
|
_na = alp_history[ _index];
|
|
|
|
if(j) {
|
|
draw_set_color(_nc);
|
|
draw_set_alpha(_na);
|
|
if(_osx == 1 && _nsx == 1) draw_line(_ox, _oy, _nx, _ny);
|
|
else if(_osx == _nsx) draw_line_width(_ox, _oy, _nx, _ny, _osx);
|
|
else draw_line_width2(_ox, _oy, _nx, _ny, _osx, _nsx, false);
|
|
draw_set_alpha(1);
|
|
}
|
|
|
|
_ox = _nx ;
|
|
_oy = _ny ;
|
|
_osx = _nsx;
|
|
_osy = _nsy;
|
|
_oc = _nc ;
|
|
_oa = _na ;
|
|
}
|
|
|
|
break;
|
|
}
|
|
} #endregion
|
|
|
|
static getPivot = function() { #region
|
|
INLINE
|
|
|
|
return [x, y];
|
|
} #endregion
|
|
|
|
static clone = function() { #region
|
|
var _p = new __part(node);
|
|
struct_override(_p, self);
|
|
return _p;
|
|
} #endregion
|
|
}
|
|
|
|
#region helper
|
|
#macro UPDATE_PART_FORWARD static updateParticleForward = function() { \
|
|
var pt = outputs[| 0]; \
|
|
for( var i = 0; i < array_length(pt.value_to); i++ ) { \
|
|
var _n = pt.value_to[i]; \
|
|
if(_n.value_from != pt) continue; \
|
|
\
|
|
if(variable_struct_exists(_n.node, "updateParticleForward")) \
|
|
_n.node.updateParticleForward(); \
|
|
} \
|
|
}
|
|
#endregion |