mirror of
https://github.com/Ttanasart-pt/Pixel-Composer.git
synced 2024-09-21 04:41:52 +02:00
316 lines
10 KiB
Plaintext
316 lines
10 KiB
Plaintext
#region create
|
|
global.node_plot_linear_keys = [ "plot", "bar chart", "graph", "waveform" ];
|
|
|
|
function Node_create_Plot_Linear(_x, _y, _group = noone, _param = {}) {
|
|
var node = new Node_Plot_Linear(_x, _y, _group);
|
|
var query = struct_try_get(_param, "query", "");
|
|
|
|
switch(query) {
|
|
case "waveform" :
|
|
case "graph" :
|
|
node.inputs[| 11].setValue(1);
|
|
break;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
#endregion
|
|
|
|
function Node_Plot_Linear(_x, _y, _group = noone) : Node_Processor(_x, _y, _group) constructor {
|
|
name = "Draw Bar / Graph";
|
|
|
|
inputs[| 0] = nodeValue("Dimension", self, JUNCTION_CONNECT.input, VALUE_TYPE.integer, DEF_SURF )
|
|
.setDisplay(VALUE_DISPLAY.vector);
|
|
|
|
inputs[| 1] = nodeValue("Data", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, [])
|
|
.setArrayDepth(1)
|
|
.setVisible(true, true);
|
|
|
|
inputs[| 2] = nodeValue("Range", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, [ 0, 1 ])
|
|
.setDisplay(VALUE_DISPLAY.slider_range);
|
|
|
|
inputs[| 3] = nodeValue("Sample frequency", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 1);
|
|
|
|
inputs[| 4] = nodeValue("Origin", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, [ 0, DEF_SURF_H / 2 ])
|
|
.setDisplay(VALUE_DISPLAY.vector);
|
|
|
|
inputs[| 5] = nodeValue("Scale", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, DEF_SURF_W / 2);
|
|
|
|
inputs[| 6] = nodeValue("Base Color", self, JUNCTION_CONNECT.input, VALUE_TYPE.color, c_white);
|
|
|
|
inputs[| 7] = nodeValue("Graph Thickness", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 1);
|
|
|
|
inputs[| 8] = nodeValue("Background", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false);
|
|
|
|
inputs[| 9] = nodeValue("Background color", self, JUNCTION_CONNECT.input, VALUE_TYPE.color, c_black);
|
|
|
|
inputs[| 10] = nodeValue("Direction", self, JUNCTION_CONNECT.input, VALUE_TYPE.integer, 0)
|
|
.setDisplay(VALUE_DISPLAY.rotation);
|
|
|
|
inputs[| 11] = nodeValue("Type", self, JUNCTION_CONNECT.input, VALUE_TYPE.integer, 0)
|
|
.setDisplay(VALUE_DISPLAY.enum_scroll, [ new scrollItem("Bar chart", s_node_plot_linear_type, 0),
|
|
new scrollItem("Graph", s_node_plot_linear_type, 1), ]);
|
|
|
|
inputs[| 12] = nodeValue("Value Offset", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 0);
|
|
|
|
inputs[| 13] = nodeValue("Color Over Sample", self, JUNCTION_CONNECT.input, VALUE_TYPE.gradient, new gradientObject(cola(c_white)))
|
|
.setMappable(27);
|
|
|
|
inputs[| 14] = nodeValue("Trim mode", self, JUNCTION_CONNECT.input, VALUE_TYPE.integer, 0)
|
|
.setDisplay(VALUE_DISPLAY.enum_scroll, [ "Range", "Window" ]);
|
|
|
|
inputs[| 15] = nodeValue("Window Size", self, JUNCTION_CONNECT.input, VALUE_TYPE.integer, 8);
|
|
|
|
inputs[| 16] = nodeValue("Window Offset", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 0);
|
|
|
|
inputs[| 17] = nodeValue("Spacing", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 1);
|
|
|
|
inputs[| 18] = nodeValue("Bar Width", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 4);
|
|
|
|
inputs[| 19] = nodeValue("Rounded Bar", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false);
|
|
|
|
inputs[| 20] = nodeValue("Path", self, JUNCTION_CONNECT.input, VALUE_TYPE.pathnode, noone)
|
|
.setVisible(true, true);
|
|
|
|
inputs[| 21] = nodeValue("Flip Value", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false);
|
|
|
|
inputs[| 22] = nodeValue("Loop", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false);
|
|
|
|
inputs[| 23] = nodeValue("Smooth", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 0)
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
inputs[| 24] = nodeValue("Color Over Value", self, JUNCTION_CONNECT.input, VALUE_TYPE.gradient, new gradientObject(cola(c_white)))
|
|
.setMappable(29);
|
|
|
|
inputs[| 25] = nodeValue("Value range", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, [ 0, 1 ] )
|
|
.setDisplay(VALUE_DISPLAY.range);
|
|
|
|
inputs[| 26] = nodeValue("Absolute", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
inputs[| 27] = nodeValueMap("Sample Gradient map", self);
|
|
|
|
inputs[| 28] = nodeValueGradientRange("Sample Gradient map range", self, inputs[| 13]);
|
|
|
|
inputs[| 29] = nodeValueMap("Value Gradient map", self);
|
|
|
|
inputs[| 30] = nodeValueGradientRange("Value Gradient map range", self, inputs[| 24]);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
outputs[| 0] = nodeValue("Surface out", self, JUNCTION_CONNECT.output, VALUE_TYPE.surface, noone);
|
|
|
|
input_display_list = [ 0,
|
|
["Data", true], 1, 12, 21, 14, 2, 3, 15, 16,
|
|
["Plot", false], 11, 4, 10, 20, 5, 22, 23,
|
|
["Render", false], 6, 13, 27, 24, 29, 25, 26, 7, 17, 18, 19,
|
|
["Background", true, 8], 9,
|
|
];
|
|
|
|
attribute_surface_depth();
|
|
|
|
static step = function() {
|
|
var _ubg = getSingleValue(8);
|
|
var _typ = getSingleValue(11);
|
|
var _trim_mode = getSingleValue(14);
|
|
|
|
var _use_path = getSingleValue(20) != noone;
|
|
|
|
inputs[| 2].setVisible(_trim_mode == 0);
|
|
inputs[| 15].setVisible(_trim_mode == 1);
|
|
inputs[| 16].setVisible(_trim_mode == 1);
|
|
|
|
inputs[| 9].setVisible(_ubg);
|
|
inputs[| 7].setVisible(_typ == 1);
|
|
inputs[| 18].setVisible(_typ == 0);
|
|
inputs[| 19].setVisible(_typ == 0);
|
|
inputs[| 22].setVisible(_typ == 1);
|
|
inputs[| 23].setVisible(_typ == 1);
|
|
|
|
inputs[| 4].setVisible(!_use_path);
|
|
inputs[| 10].setVisible(!_use_path);
|
|
|
|
inputs[| 13].mappableStep();
|
|
inputs[| 24].mappableStep();
|
|
}
|
|
|
|
static drawOverlay = function(hover, active, _x, _y, _s, _mx, _my, _snx, _sny) {
|
|
PROCESSOR_OVERLAY_CHECK
|
|
|
|
var _use_path = current_data[20] != noone;
|
|
|
|
if(!_use_path) {
|
|
var a = inputs[| 4].drawOverlay(hover, active, _x, _y, _s, _mx, _my, _snx, _sny);
|
|
active &= !a;
|
|
}
|
|
|
|
var a = inputs[| 28].drawOverlay(hover, active, _x, _y, _s, _mx, _my, _snx, _sny, current_data[0]); active &= !a;
|
|
var a = inputs[| 30].drawOverlay(hover, active, _x, _y, _s, _mx, _my, _snx, _sny, current_data[0]); active &= !a;
|
|
}
|
|
|
|
static processData = function(_outSurf, _data, _output_index, _array_index) {
|
|
var _dim = _data[ 0];
|
|
var _dat = _data[ 1];
|
|
var _ran = _data[ 2];
|
|
var _sam = _data[ 3]; _sam = max(1, _sam);
|
|
var _ori = _data[ 4];
|
|
var _amp = _data[ 5];
|
|
var _lth = _data[ 7];
|
|
var _ubg = _data[ 8];
|
|
var _bgc = _data[ 9];
|
|
var _ang = _data[10];
|
|
var _typ = _data[11];
|
|
var _off = _data[12];
|
|
|
|
var _trim_mode = _data[14];
|
|
var _win_size = _data[15];
|
|
var _win_offs = _data[16]; _win_offs = max(0, _win_offs);
|
|
|
|
var _pnt_spac = _data[17];
|
|
|
|
var _bar_wid = _data[18];
|
|
var _bar_rnd = _data[19];
|
|
|
|
var _path = _data[20];
|
|
var _flip = _data[21];
|
|
var _loop = _data[22];
|
|
var _smt = _data[23];
|
|
|
|
var _lcl = _data[ 6];
|
|
var _cls = _data[13];
|
|
var _cls_map = _data[27];
|
|
var _cls_rng = _data[28];
|
|
var _clv = _data[24];
|
|
var _clv_map = _data[29];
|
|
var _clv_rng = _data[30];
|
|
var _clv_r = _data[25];
|
|
var _clv_a = _data[26];
|
|
|
|
_outSurf = surface_verify(_outSurf, _dim[0], _dim[1], attrDepth());
|
|
|
|
surface_set_target(_outSurf);
|
|
if(_ubg) draw_clear(_bgc);
|
|
else DRAW_CLEAR
|
|
|
|
var _len = array_length(_dat);
|
|
var _st = clamp(_ran[0], 0, 1) * _len;
|
|
var _ed = clamp(_ran[1], 0, 1) * _len;
|
|
var ox, oy, nx, ny, fx, fy;
|
|
|
|
if(_typ == 1)
|
|
draw_set_circle_precision(4);
|
|
|
|
var _dat_amo = array_length(_dat);
|
|
var _smp_data = [];
|
|
var _ind = 0;
|
|
|
|
if(_trim_mode == 0) {
|
|
for( var i = _st; i < _ed; i += _sam )
|
|
_smp_data[_ind++] = _dat[i];
|
|
} else if(_trim_mode == 1) {
|
|
for( var i = 0; i < _win_size; i++ ) {
|
|
_ind = _win_offs + i * _sam;
|
|
|
|
if(_ind >= _dat_amo) break;
|
|
if(frac(_ind) != 0 && floor(_ind) + 1 < _dat_amo)
|
|
_smp_data[i] = lerp(_dat[floor(_ind)], _dat[floor(_ind) + 1], frac(_ind));
|
|
else
|
|
_smp_data[i] = _dat[_ind];
|
|
|
|
if(_flip)
|
|
_smp_data[i] = -_smp_data[i];
|
|
}
|
|
}
|
|
|
|
var amo = array_length(_smp_data);
|
|
var _px, _py, _ang_nor, _val, _col_sam, _col_val;
|
|
var _pnt, _ppnt = undefined;
|
|
var _bar_spc = _typ == 1? _pnt_spac + 1 : _pnt_spac + _bar_wid;
|
|
var _oc;
|
|
|
|
for( var i = 0; i < amo; i++ ) {
|
|
if(_path == noone) {
|
|
_px = _ori[0] + lengthdir_x(i * _bar_spc, _ang);
|
|
_py = _ori[1] + lengthdir_y(i * _bar_spc, _ang);
|
|
} else {
|
|
_pnt = _path.getPointRatio(i / amo);
|
|
_ppnt ??= _path.getPointRatio(i / amo - 0.001);
|
|
|
|
_px = _pnt.x;
|
|
_py = _pnt.y;
|
|
_ang = point_direction(_ppnt.x, _ppnt.y, _pnt.x, _pnt.y)
|
|
|
|
_ppnt = _pnt;
|
|
}
|
|
|
|
_ang_nor = _ang + 90;
|
|
_val = _smp_data[i] + _off;
|
|
_col_sam = evaluate_gradient_map(i / amo, _cls, _cls_map, _cls_rng, inputs[| 13]);
|
|
|
|
var _val_p = _clv_a? abs(_val) : _val;
|
|
var _val_prog = (_val_p - _clv_r[0]) / (_clv_r[1] - _clv_r[0]);
|
|
_col_val = evaluate_gradient_map(_val_prog, _clv, _clv_map, _clv_rng, inputs[| 24]);
|
|
|
|
var _c1 = colorMultiply(_lcl, _col_sam);
|
|
var _c2 = _col_val;
|
|
var _col_final = colorMultiply(_c1, _c2);
|
|
|
|
draw_set_color(_col_final);
|
|
|
|
nx = _px + lengthdir_x(_amp * _val, _ang_nor);
|
|
ny = _py + lengthdir_y(_amp * _val, _ang_nor);
|
|
|
|
switch(_typ) {
|
|
case 0 :
|
|
if(_bar_rnd) draw_line_round(_px, _py, nx, ny, _bar_wid);
|
|
else draw_line_width(_px, _py, nx, ny, _bar_wid);
|
|
break;
|
|
case 1 :
|
|
if(i > _st) {
|
|
if(_smt > 0) {
|
|
var dist = dot_product(nx - ox, ny - oy, lengthdir_x(1, _ang), lengthdir_y(1, _ang));
|
|
var _b0x = ox + lengthdir_x(dist * _smt, _ang);
|
|
var _b0y = oy + lengthdir_y(dist * _smt, _ang);
|
|
var _b1x = nx + lengthdir_x(dist * _smt, _ang + 180);
|
|
var _b1y = ny + lengthdir_y(dist * _smt, _ang + 180);
|
|
|
|
var _ox = ox, _oy = oy, _nx, _ny;
|
|
|
|
for( var j = 1; j <= 8; j++ ) {
|
|
var _t = 1 - j / 8;
|
|
_nx = ox * power(_t, 3) + 3 * _b0x * power(_t, 2) * (1 - _t) + 3 * _b1x * (_t) * power(1 - _t, 2) + nx * power(1 - _t, 3);
|
|
_ny = oy * power(_t, 3) + 3 * _b0y * power(_t, 2) * (1 - _t) + 3 * _b1y * (_t) * power(1 - _t, 2) + ny * power(1 - _t, 3);
|
|
|
|
if(_lth > 1) draw_line_round(_ox, _oy, _nx, _ny, _lth);
|
|
else draw_line(_ox, _oy, _nx, _ny);
|
|
|
|
_ox = _nx;
|
|
_oy = _ny;
|
|
}
|
|
} else {
|
|
if(_lth > 1) draw_line_round_color(ox, oy, nx, ny, _lth, _oc, _col_final);
|
|
else draw_line_color(ox, oy, nx, ny, _oc, _col_final);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
ox = nx;
|
|
oy = ny;
|
|
_oc = _col_final;
|
|
|
|
if(i == 0) {
|
|
fx = nx;
|
|
fy = ny;
|
|
}
|
|
}
|
|
|
|
if(_loop && amo > 1 && _typ == 1)
|
|
draw_line_round(fx, fy, nx, ny, _lth);
|
|
|
|
draw_set_circle_precision(64);
|
|
surface_reset_target();
|
|
return _outSurf;
|
|
}
|
|
} |