mirror of
https://github.com/Ttanasart-pt/Pixel-Composer.git
synced 2024-12-25 14:36:13 +01:00
188 lines
No EOL
6.1 KiB
Text
188 lines
No EOL
6.1 KiB
Text
function Node_Seperate_Shape(_x, _y, _group = noone) : Node(_x, _y, _group) constructor {
|
|
name = "Separate Shape";
|
|
//error_update_enabled = true;
|
|
|
|
inputs[| 0] = nodeValue("Surface in", self, JUNCTION_CONNECT.input, VALUE_TYPE.surface, 0)
|
|
.rejectArray();
|
|
|
|
inputs[| 1] = nodeValue("Tolerance", self, JUNCTION_CONNECT.input, VALUE_TYPE.float, 0.2)
|
|
.setDisplay(VALUE_DISPLAY.slider, [0, 1, 0.01])
|
|
.rejectArray();
|
|
|
|
inputs[| 2] = nodeValue("Override color", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, true)
|
|
.rejectArray();
|
|
|
|
inputs[| 3] = nodeValue("Color", self, JUNCTION_CONNECT.input, VALUE_TYPE.color, c_white)
|
|
.rejectArray();
|
|
|
|
inputs[| 4] = nodeValue("Ignore blank", self, JUNCTION_CONNECT.input, VALUE_TYPE.boolean, false, "Skip empty and black shape.")
|
|
.rejectArray();
|
|
|
|
outputs[| 0] = nodeValue("Surface out", self, JUNCTION_CONNECT.output, VALUE_TYPE.surface, noone);
|
|
|
|
outputs[| 1] = nodeValue("Boundary data", self, JUNCTION_CONNECT.output, VALUE_TYPE.integer, []);
|
|
|
|
input_display_list = [
|
|
["Shape", false], 0, 1, 4,
|
|
["Render", false], 2, 3,
|
|
]
|
|
|
|
attribute_surface_depth();
|
|
attribute_auto_execute(true);
|
|
|
|
temp_surface = [ surface_create(1, 1), surface_create(1, 1) ];
|
|
surface_buffer = buffer_create(1 * 1 * 4, buffer_fixed, 2);
|
|
surface_w = 1;
|
|
surface_h = 1;
|
|
|
|
attributes[? "max_shape"] = 32;
|
|
array_push(attributeEditors, ["Maximum shapes", "max_shape",
|
|
new textBox(TEXTBOX_INPUT.number, function(val) { attributes[? "max_shape"] = val; })]);
|
|
|
|
function get_color_buffer(_x, _y) {
|
|
buffer_seek(surface_buffer, buffer_seek_start, (surface_w * _y + _x) * 4);
|
|
var c = buffer_read(surface_buffer, buffer_u32);
|
|
return c;
|
|
}
|
|
|
|
_prev_type = -1;
|
|
|
|
static onInspectorUpdate = function() { separateShape(); }
|
|
|
|
static update = function() {
|
|
if(attributes[? "auto_exe"])
|
|
separateShape();
|
|
}
|
|
|
|
static separateShape = function() {
|
|
var _inSurf = inputs[| 0].getValue();
|
|
var _thres = inputs[| 1].getValue();
|
|
var _ovr = inputs[| 2].getValue();
|
|
var _ovrclr = inputs[| 3].getValue();
|
|
var _ignore = inputs[| 4].getValue();
|
|
var t = current_time;
|
|
|
|
if(!is_surface(_inSurf)) return;
|
|
|
|
var ww = surface_get_width(_inSurf);
|
|
var hh = surface_get_height(_inSurf);
|
|
surface_w = ww;
|
|
surface_h = hh;
|
|
|
|
for(var i = 0; i < 2; i++) {
|
|
temp_surface[i] = surface_verify(temp_surface[i], ww, hh, attrDepth());
|
|
|
|
surface_set_target(temp_surface[i]);
|
|
DRAW_CLEAR
|
|
surface_reset_target();
|
|
}
|
|
|
|
shader_set(sh_seperate_shape_index);
|
|
shader_set_uniform_i(shader_get_uniform(sh_seperate_shape_index, "ignore"), _ignore);
|
|
surface_set_target(temp_surface[1]);
|
|
draw_sprite_stretched(s_fx_pixel, 0, 0, 0, ww, hh);
|
|
surface_reset_target();
|
|
shader_reset();
|
|
|
|
shader_set(sh_seperate_shape_ite);
|
|
shader_set_uniform_i(shader_get_uniform(sh_seperate_shape_ite, "ignore"), _ignore);
|
|
shader_set_uniform_f(shader_get_uniform(sh_seperate_shape_ite, "dimension"), ww, hh);
|
|
shader_set_uniform_f(shader_get_uniform(sh_seperate_shape_ite, "threshold"), _thres);
|
|
if(is_surface(_inSurf))
|
|
texture_set_stage(shader_get_sampler_index(sh_seperate_shape_ite, "map"), surface_get_texture(_inSurf));
|
|
|
|
var res_index = 0, iteration = ww + hh;
|
|
for(var i = 0; i <= iteration; i++) {
|
|
var bg = i % 2;
|
|
var fg = !bg;
|
|
|
|
surface_set_target(temp_surface[bg]);
|
|
DRAW_CLEAR
|
|
BLEND_OVERRIDE;
|
|
draw_surface_safe(temp_surface[fg], 0, 0);
|
|
BLEND_NORMAL;
|
|
surface_reset_target();
|
|
|
|
res_index = bg;
|
|
}
|
|
|
|
shader_reset();
|
|
|
|
var _pixel_surface = surface_create_valid(attributes[? "max_shape"], 1);
|
|
surface_set_target(_pixel_surface);
|
|
DRAW_CLEAR
|
|
BLEND_OVERRIDE;
|
|
shader_set(sh_seperate_shape_counter);
|
|
texture_set_stage(shader_get_sampler_index(sh_seperate_shape_counter, "surface"), surface_get_texture(temp_surface[res_index]));
|
|
shader_set_uniform_f_array_safe(shader_get_uniform(sh_seperate_shape_counter, "dimension"), [ ww, hh ]);
|
|
shader_set_uniform_i(shader_get_uniform(sh_seperate_shape_counter, "maxShape"), attributes[? "max_shape"]);
|
|
shader_set_uniform_i(shader_get_uniform(sh_seperate_shape_counter, "ignore"), _ignore);
|
|
draw_sprite_ext(s_fx_pixel, 0, 0, 0, attributes[? "max_shape"], 1, 0, c_white, 1);
|
|
shader_reset();
|
|
BLEND_NORMAL;
|
|
surface_reset_target();
|
|
|
|
var px = surface_getpixel(_pixel_surface, 0, 0);
|
|
|
|
if(px == 0) return;
|
|
|
|
var _outSurf, _val;
|
|
_val = array_create(px);
|
|
outputs[| 0].setValue(_val);
|
|
|
|
var _boundary = array_create(px);
|
|
|
|
buffer_delete(surface_buffer);
|
|
surface_buffer = buffer_create(ww * hh * 4, buffer_fixed, 2);
|
|
buffer_get_surface(surface_buffer, temp_surface[res_index], 0);
|
|
|
|
for(var i = 0; i < px; i++) {
|
|
_outSurf = surface_create_valid(ww, hh);
|
|
_val[@ i] = _outSurf;
|
|
|
|
surface_set_target(_outSurf);
|
|
DRAW_CLEAR
|
|
BLEND_OVERRIDE;
|
|
shader_set(sh_seperate_shape_sep);
|
|
var ccx = surface_getpixel_ext(_pixel_surface, 1 + i, 0);
|
|
var alpha = (ccx >> 24) & 255;
|
|
var blue = (ccx >> 16) & 255;
|
|
var green = (ccx >> 8) & 255;
|
|
var red = ccx & 255;
|
|
|
|
var min_x = floor(red / 255 * ww);
|
|
var min_y = floor(green / 255 * hh);
|
|
var max_x = ceil(blue / 255 * ww);
|
|
var max_y = ceil(alpha / 255 * hh);
|
|
var t = max_y;
|
|
var b = min_y;
|
|
var l = max_x;
|
|
var r = min_x;
|
|
|
|
for( var j = min_x; j < max_x; j++ )
|
|
for( var k = min_y; k < max_y; k++ ) {
|
|
var _sc = get_color_buffer(j, k);
|
|
if(_sc != ccx) continue;
|
|
|
|
t = min(t, k);
|
|
b = max(b, k);
|
|
l = min(l, j);
|
|
r = max(r, j);
|
|
}
|
|
|
|
_boundary[i] = [l, t, r, b];
|
|
|
|
if(is_surface(_inSurf))
|
|
texture_set_stage(shader_get_sampler_index(sh_seperate_shape_sep, "original"), surface_get_texture(_inSurf));
|
|
shader_set_uniform_f(shader_get_uniform(sh_seperate_shape_sep, "color"), red, green, blue, alpha);
|
|
shader_set_uniform_i(shader_get_uniform(sh_seperate_shape_sep, "override"), _ovr);
|
|
shader_set_uniform_f_array_safe(shader_get_uniform(sh_seperate_shape_sep, "overColor"), colToVec4(_ovrclr));
|
|
draw_surface_safe(temp_surface[res_index], 0, 0);
|
|
shader_reset();
|
|
BLEND_NORMAL;
|
|
surface_reset_target();
|
|
}
|
|
|
|
outputs[| 1].setValue(_boundary,,, false);
|
|
}
|
|
} |