mirrors/Pixel-Composer
1
0
Fork 0
mirror of https://github.com/Ttanasart-pt/Pixel-Composer.git synced 2025-01-14 08:16:34 +01:00
Code Issues Projects Releases Packages Wiki Activity
Pixel-Composer/scripts/node_registry/node_registry.gml
Tanasart 6f7cd0aca7 Fix "Override UI Font" setting not working.
2025-01-09 10:22:47 +07:00

2055 lines
122 KiB
Text
Raw Blame History

#region globalvar
globalvar ALL_NODES, NODE_CATEGORY, NODE_PB_CATEGORY, NODE_PCX_CATEGORY;
globalvar SUPPORTER_NODES, NEW_NODES;
globalvar NODE_PAGE_DEFAULT;
ALL_NODES = ds_map_create();
NODE_CATEGORY = ds_list_create();
NODE_PB_CATEGORY = ds_list_create();
NODE_PCX_CATEGORY = ds_list_create();
SUPPORTER_NODES = ds_list_create();
NEW_NODES = ds_list_create();
global.__currPage = "";
global.__currNewPage = "";
#macro NODE_ADD_CAT if(!IS_CMD) addNodeCatagory
#endregion
function NodeObject(_name, _spr, _node, _tooltip = "") constructor {
name = _name;
spr = _spr;
node = _node;
icon = noone;
nodeName = script_get_name(node);
createFn = noone;
createParam = noone;
tags = [];
tooltip = _tooltip;
new_node = false;
tooltip_spr = noone;
deprecated = false;
show_in_recent = true;
show_in_global = true;
patreon = false;
testable = true;
input_type_mask = 0b0;
output_type_mask = 0b0;
_fn = registerFunctionLite("New node", _name, function(n) /*=>*/ { PANEL_GRAPH.createNodeHotkey(n); }, [ nodeName ]);
_fn.spr = _spr;
if(!IS_CMD) {
var pth = DIRECTORY + $"Nodes/Tooltip/{node}.png";
if(file_exists_empty(pth)) tooltip_spr = sprite_add(pth, 0, false, false, 0, 0);
if(struct_has(global.NODE_GUIDE, node)) {
var _n = global.NODE_GUIDEarn[$ node];
name = _n.name;
if(_n.tooltip != "")
tooltip = _n.tooltip;
}
}
static setTags = function(_tags) { tags = _tags; return self; }
static setSpr = function(_spr) { spr = _spr; return self; }
static setTooltip = function(_tool) { tooltip = _tool; return self; }
static setBuild = function(_fn) { createFn = _fn; return self; }
static setParam = function(_par) { createParam = _par; return self; }
static setIO = function(t) { for(var i = 0; i < argument_count; i++) { input_type_mask |= value_bit(argument[i]); output_type_mask |= value_bit(argument[i]); } return self; }
static setVersion = function(version) {
INLINE
if(IS_CMD) return self;
new_node = version >= LATEST_VERSION;
if(new_node) {
if(global.__currPage != global.__currNewPage) {
ds_list_add(NEW_NODES, global.__currPage);
global.__currNewPage = global.__currPage;
}
ds_list_add(NEW_NODES, self);
}
return self;
}
static setIcon = function(_icon) {
INLINE
if(IS_CMD) return self;
icon = _icon;
return self;
}
static isDeprecated = function() {
INLINE
if(IS_CMD) return self;
deprecated = true;
return self;
}
static hideRecent = function() {
INLINE
if(IS_CMD) return self;
show_in_recent = false;
testable = false;
variable_struct_remove(FUNCTIONS, _fn.fnName);
return self;
}
static notTest = function() { testable = false; return self; }
static hideGlobal = function() {
INLINE
if(IS_CMD) return self;
show_in_global = false;
return self;
}
static patreonExtra = function() {
INLINE
if(IS_CMD) return self;
patreon = true;
ds_list_add(SUPPORTER_NODES, self);
return self;
}
static getName = function() { return __txt_node_name(node, name); }
static getTooltip = function() { return __txt_node_tooltip(node, tooltip); }
static build = function(_x = 0, _y = 0, _group = PANEL_GRAPH.getCurrentContext(), _param = {}) {
INLINE
if(createParam != noone) struct_append(_param, createParam);
var _node = createFn == noone? new node(_x, _y, _group, _param) : createFn(_x, _y, _group, _param);
return _node;
}
static drawGrid = function(_x, _y, _mx, _my, grid_size, _param = {}) {
var spr_x = _x + grid_size / 2;
var spr_y = _y + grid_size / 2;
var _spw = sprite_get_width(spr);
var _sph = sprite_get_height(spr);
var _ss = grid_size / max(_spw, _sph) * 0.75;
gpu_set_tex_filter(true);
draw_sprite_uniform(spr, 0, spr_x, spr_y, _ss);
gpu_set_tex_filter(false);
if(new_node) {
draw_sprite_ui_uniform(THEME.node_new_badge, 0, _x + grid_size - ui(12), _y + ui(6),, COLORS._main_accent);
draw_sprite_ui_uniform(THEME.node_new_badge, 1, _x + grid_size - ui(12), _y + ui(6));
}
if(deprecated) {
draw_sprite_ui_uniform(THEME.node_deprecated_badge, 0, _x + grid_size - ui(12), _y + ui(6),, COLORS._main_value_negative);
draw_sprite_ui_uniform(THEME.node_deprecated_badge, 1, _x + grid_size - ui(12), _y + ui(6));
}
var fav = struct_exists(global.FAV_NODES, nodeName);
if(fav) {
gpu_set_tex_filter(true);
draw_sprite_ui_uniform(THEME.star, 0, _x + grid_size - ui(10), _y + grid_size - ui(10), .8, COLORS._main_accent, 1.);
gpu_set_tex_filter(false);
}
var spr_x = _x + grid_size - 4;
var spr_y = _y + 4;
if(IS_PATREON && patreon) {
BLEND_SUBTRACT
gpu_set_colorwriteenable(0, 0, 0, 1);
draw_sprite_ext(THEME.patreon_supporter, 0, spr_x, spr_y, 1, 1, 0, c_white, 1);
gpu_set_colorwriteenable(1, 1, 1, 1);
BLEND_NORMAL
draw_sprite_ext(THEME.patreon_supporter, 1, spr_x, spr_y, 1, 1, 0, COLORS._main_accent, 1);
if(point_in_circle(_mx, _my, spr_x, spr_y, 10)) TOOLTIP = __txt("Supporter exclusive");
}
if(icon) draw_sprite_ext(icon, 0, spr_x, spr_y, 1, 1, 0, c_white, 1);
}
static drawList = function(_x, _y, _mx, _my, _h, _w, _param = {}) {
var fav = struct_exists(global.FAV_NODES, nodeName);
if(fav) {
gpu_set_tex_filter(true);
draw_sprite_ui_uniform(THEME.star, 0, _x + ui(16), _y + _h / 2, .8, COLORS._main_accent, 1.);
gpu_set_tex_filter(false);
}
var spr_x = _x + ui(32) + _h / 2;
var spr_y = _y + _h / 2;
var ss = (_h - ui(8)) / max(sprite_get_width(spr), sprite_get_height(spr));
gpu_set_tex_filter(true);
draw_sprite_ext(spr, 0, spr_x, spr_y, ss, ss, 0, c_white, 1);
gpu_set_tex_filter(false);
var tx = spr_x + _h / 2 + ui(4);
var ty = _y + _h / 2;
if(new_node) {
var _nx = _w - ui(6 + 18);
draw_sprite_ui_uniform(THEME.node_new_badge, 0, _nx, _y + _h / 2,, COLORS._main_accent);
draw_sprite_ui_uniform(THEME.node_new_badge, 1, _nx, _y + _h / 2);
}
if(deprecated) {
var _nx = _w - ui(6 + 18);
draw_sprite_ui_uniform(THEME.node_deprecated_badge, 0, _nx, _y + _h / 2,, COLORS._main_value_negative);
draw_sprite_ui_uniform(THEME.node_deprecated_badge, 1, _nx, _y + _h / 2);
}
var _txt = getName();
var _query = struct_try_get(_param, "query", "");
var _range = struct_try_get(_param, "range", 0);
if(_query != "") {
draw_set_text(f_p2, fa_left, fa_center, COLORS._main_text_sub);
draw_text_add(tx, ty, _txt);
tx += string_width(_txt);
draw_sprite_ext(THEME.arrow, 0, tx + ui(12), ty, 1, 1, 0, COLORS._main_icon, 1);
tx += ui(24);
_query = string_title(_query);
draw_set_text(f_p2, fa_left, fa_center, COLORS._main_text);
if(_range == 0) draw_text_add(tx, ty, _query);
else draw_text_match_range(tx, ty, _query, _range);
tx += string_width(_query);
} else {
draw_set_text(f_p2, fa_left, fa_center, COLORS._main_text);
if(_range == 0) draw_text_add(tx, ty, _txt);
else draw_text_match_range(tx, ty, _txt, _range);
tx += string_width(_txt);
}
if(IS_PATREON && patreon) {
var spr_x = tx + ui(4);
var spr_y = _y + _h / 2 - ui(6);
gpu_set_colorwriteenable(0, 0, 0, 1); BLEND_SUBTRACT
draw_sprite_ext(THEME.patreon_supporter, 0, spr_x, spr_y, 1, 1, 0, c_white, 1);
gpu_set_colorwriteenable(1, 1, 1, 1); BLEND_NORMAL
draw_sprite_ext(THEME.patreon_supporter, 1, spr_x, spr_y, 1, 1, 0, COLORS._main_accent, 1);
if(point_in_circle(_mx, _my, spr_x, spr_y, ui(10))) TOOLTIP = __txt("Supporter exclusive");
tx += ui(12);
}
return tx;
}
}
function nodeBuild(_name, _x, _y, _group = PANEL_GRAPH.getCurrentContext()) {
INLINE
if(!ds_map_exists(ALL_NODES, _name)) {
log_warning("LOAD", $"Node type {_name} not found");
return noone;
}
var _node = ALL_NODES[? _name];
var _bnode = _node.build(_x, _y, _group);
return _bnode;
}
function addNodeObject(_list, _name = "", _node = noone, tooltip = "") {
var _nodeName = script_get_name(_node);
if(ds_map_exists(ALL_NODES, _nodeName)) {
var _n = ALL_NODES[? _nodeName];
if(tooltip != "") _n.setTooltip(tooltip);
ds_list_add(_list, _n);
return _n;
}
var _spr = asset_get_index($"s_{string_lower(_nodeName)}");
if(_spr == -1) _spr = s_node_icon;
var _n = new NodeObject(_name, _spr, _node, tooltip);
if(tooltip != "") _n.setTooltip(tooltip);
ALL_NODES[? _nodeName] = _n;
ds_list_add(_list, _n);
return _n;
}
function addNodeCatagory( name, list, filter = [], color = noone) { ds_list_add(NODE_CATEGORY, { name, list, filter, color }); global.__currPage = name; }
function addNodePBCatagory( name, list, filter = []) { ds_list_add(NODE_PB_CATEGORY, { name, list, filter }); }
function addNodePCXCatagory( name, list, filter = []) { ds_list_add(NODE_PCX_CATEGORY, { name, list, filter }); }
////- Nodes
function __read_node_folder(dir) {
var _name = filename_name_only(dir);
var _info = dir + "/info.json";
if(!file_exists(_info)) {
print($"NODE ERROR: Cannot find info.json for {dir}.");
return;
}
var _data = json_load_struct(_info);
var _name = _data[$ "name"];
var _iref = _data[$ "internalRef"];
var _iref = _data[$ "internalRef"];
addNodeObject(input, "Image", Node_Image, "Load a single image from your computer.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Image);
}
function __initNodes() {
global.__currPage = "";
global.__startPage = 0;
global.FAV_NODES = {};
if(!IS_CMD) {
var favPath = DIRECTORY + "Nodes/fav.json";
if(file_exists_empty(favPath)) {
var favs = json_load_struct(favPath);
for (var i = 0, n = array_length(favs); i < n; i++)
global.FAV_NODES[$ favs[i]] = 1;
}
var recPath = DIRECTORY + "Nodes/recent.json";
global.RECENT_NODES = file_exists_empty(recPath)? json_load_struct(recPath) : [];
if(!is_array(global.RECENT_NODES)) global.RECENT_NODES = [];
}
NODE_PAGE_DEFAULT = ds_list_size(NODE_CATEGORY);
ADD_NODE_PAGE = NODE_PAGE_DEFAULT;
// NODE DATA
var dir = $"{DIRECTORY}Nodes/Data/Internal/";
if(directory_exists(dir)) {
var _dirs = [];
var _f = file_find_first(dir + "*", 0);
var f, p;
while(_f != "") {
f = _f;
p = dir + f;
_f = file_find_next();
if(!directory_exists(p)) continue;
array_push(_dirs, p);
}
file_find_close();
array_foreach(_dirs, function(d) /*=>*/ {return __read_node_folder(d)});
}
// NODE LIST
var fav = ds_list_create();
NODE_ADD_CAT("Home", fav);
#region group
var group = ds_list_create();
NODE_ADD_CAT("Group", group, ["Node_Group"], COLORS.node_blend_collection);
ds_list_add(group, "Groups");
addNodeObject(group, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(group, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(group, "Thumbnail", Node_Group_Thumbnail)
.setIO(VALUE_TYPE.surface).hideRecent();
#endregion
#region for
var iter = ds_list_create();
NODE_ADD_CAT("Loop", iter, ["Node_Iterate"], COLORS.node_blend_loop); //#For
ds_list_add(iter, "Groups");
addNodeObject(iter, "Loop Input", Node_Iterator_Input)
.setIO(VALUE_TYPE.any).setSpr(s_node_loop_input).hideRecent();
addNodeObject(iter, "Loop Output", Node_Iterator_Output)
.setIO(VALUE_TYPE.any).setSpr(s_node_loop_output).hideRecent();
addNodeObject(iter, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(iter, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(iter, "Thumbnail", Node_Group_Thumbnail)
.setIO(VALUE_TYPE.surface).hideRecent();
ds_list_add(iter, "Loops");
addNodeObject(iter, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(iter, "Loop amount", Node_Iterator_Length)
.setIO(VALUE_TYPE.float).setSpr(s_node_iterator_amount).hideRecent();
#endregion
#region for inline
var iter_il = ds_list_create();
NODE_ADD_CAT("Loop", iter_il, ["Node_Iterate_Inline"], COLORS.node_blend_loop); //#For inline
ds_list_add(iter_il, "Loops");
addNodeObject(iter_il, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(iter_il, "Loop amount", Node_Iterator_Length)
.setIO(VALUE_TYPE.float).setSpr(s_node_iterator_amount).hideRecent();
#endregion
#region for each
var itere = ds_list_create();
NODE_ADD_CAT("Loop", itere, ["Node_Iterate_Each"], COLORS.node_blend_loop); //#Foreach
ds_list_add(itere, "Groups");
addNodeObject(itere, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(itere, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(itere, "Thumbnail", Node_Group_Thumbnail)
.setIO(VALUE_TYPE.surface).hideRecent();
ds_list_add(itere, "Loops");
addNodeObject(itere, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(itere, "Array Length", Node_Iterator_Each_Length)
.setIO(VALUE_TYPE.float).setSpr(s_node_iterator_length).hideRecent();
#endregion
#region for each inline
var itere_il = ds_list_create();
NODE_ADD_CAT("Loop", itere_il, ["Node_Iterate_Each_Inline"], COLORS.node_blend_loop); //#Foreach inline
ds_list_add(itere_il, "Loops");
addNodeObject(itere_il, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(itere_il, "Array Length", Node_Iterator_Length)
.setIO(VALUE_TYPE.float).hideRecent();
#endregion
#region iterate filter
var filter = ds_list_create();
NODE_ADD_CAT("Filter", filter, ["Node_Iterate_Filter"], COLORS.node_blend_loop); //#Loop filter
ds_list_add(filter, "Groups");
addNodeObject(filter, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(filter, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(filter, "Thumbnail", Node_Group_Thumbnail)
.setIO(VALUE_TYPE.surface).hideRecent();
ds_list_add(filter, "Loops");
addNodeObject(filter, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(filter, "Array Length", Node_Iterator_Each_Length)
.setIO(VALUE_TYPE.float).setSpr(s_node_iterator_length).hideRecent();
#endregion
#region iterate filter inline
var filter_il = ds_list_create();
NODE_ADD_CAT("Filter", filter_il, ["Node_Iterate_Filter_Inline"], COLORS.node_blend_loop); //#Loop filter inline
ds_list_add(filter_il, "Loops");
addNodeObject(filter_il, "Index", Node_Iterator_Index)
.setIO(VALUE_TYPE.float).hideRecent();
addNodeObject(filter_il, "Array Length", Node_Iterator_Length)
.setIO(VALUE_TYPE.float).hideRecent();
#endregion
#region iterate feedback
var feed = ds_list_create();
NODE_ADD_CAT("Feedback", feed, ["Node_Feedback"], COLORS.node_blend_feedback); //#Feedback
ds_list_add(feed, "Groups");
addNodeObject(feed, "Input", Node_Feedback_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(feed, "Output", Node_Feedback_Output)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(feed, "Thumbnail", Node_Group_Thumbnail)
.setIO(VALUE_TYPE.surface).hideRecent();
#endregion
#region vfx
var vfx = ds_list_create();
NODE_ADD_CAT("VFX", vfx, ["Node_VFX_Group", "Node_VFX_Group_Inline"], COLORS.node_blend_vfx);
ds_list_add(vfx, "Groups");
addNodeObject(vfx, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(vfx, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(vfx, "Renderer", Node_VFX_Renderer_Output)
.setIO(VALUE_TYPE.surface, VALUE_TYPE.particle).setSpr(s_node_vfx_render_output).hideRecent().hideGlobal();
ds_list_add(vfx, "Main");
addNodeObject(vfx, "Spawner", Node_VFX_Spawner, "Spawn new particles.")
.setIO(VALUE_TYPE.particle).setSpr(s_node_vfx_spawn).hideRecent();
addNodeObject(vfx, "Renderer", Node_VFX_Renderer, "Render particle objects to surface.")
.setIO(VALUE_TYPE.particle).setSpr(s_node_vfx_render).hideRecent();
ds_list_add(vfx, "Affectors");
addNodeObject(vfx, "Accelerate", Node_VFX_Accelerate, "Change the speed of particle in range.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Destroy", Node_VFX_Destroy, "Destroy particle in range.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Attract", Node_VFX_Attract, "Attract particle in range to one point.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Wind", Node_VFX_Wind, "Move particle in range.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Vortex", Node_VFX_Vortex, "Rotate particle around a point.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Turbulence", Node_VFX_Turbulence, "Move particle in range randomly.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Repel", Node_VFX_Repel, "Move particle away from point.")
.setIO(VALUE_TYPE.particle).hideRecent();
addNodeObject(vfx, "Oscillate", Node_VFX_Oscillate, "Swing particle around its original trajectory.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(11560);
addNodeObject(vfx, "Boids", Node_VFX_Boids, "Apply boids algorithm to create a flock behaviour.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(1_18_01_0);
ds_list_add(vfx, "Generates");
addNodeObject(vfx, "VFX Trail", Node_VFX_Trail, "Generate path from particle movement.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(11560);
addNodeObject(vfx, "VFX Triangulate", Node_VFX_Triangulate, "Render line between particles.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(11670);
ds_list_add(vfx, "Variables");
addNodeObject(vfx, "VFX Variable", Node_VFX_Variable, "Extract variable from particle objects.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(1120);
addNodeObject(vfx, "VFX Override", Node_VFX_Override, "Replace particle variable with a new one.")
.setIO(VALUE_TYPE.particle).hideRecent().setVersion(1120);
#endregion
#region rigidSim
var rigidSim = ds_list_create();
NODE_ADD_CAT("RigidSim", rigidSim, ["Node_Rigid_Group", "Node_Rigid_Group_Inline"], COLORS.node_blend_simulation);
ds_list_add(rigidSim, "Group");
addNodeObject(rigidSim, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(rigidSim, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(rigidSim, "Render", Node_Rigid_Render_Output)
.setIO(VALUE_TYPE.rigid, VALUE_TYPE.surface).hideRecent().hideGlobal();
addNodeObject(rigidSim, "RigidSim Global", Node_Rigid_Global)
.setIO(VALUE_TYPE.rigid).setVersion(1110).hideRecent();
ds_list_add(rigidSim, "RigidSim");
addNodeObject(rigidSim, "Object", Node_Rigid_Object, "Spawn a rigidbody object.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1110);
addNodeObject(rigidSim, "Object Spawner", Node_Rigid_Object_Spawner, "Spawn multiple rigidbody objects.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1110);
addNodeObject(rigidSim, "Wall", Node_Rigid_Wall)
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(11680);
addNodeObject(rigidSim, "Render", Node_Rigid_Render, "Render rigidbody object to surface.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1110);
addNodeObject(rigidSim, "Apply Force", Node_Rigid_Force_Apply, "Apply force to objects.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1110);
addNodeObject(rigidSim, "Activate Physics", Node_Rigid_Activate, "Enable or disable rigidbody object.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1110);
ds_list_add(rigidSim, "Variables");
addNodeObject(rigidSim, "Rigidbody Variable", Node_Rigid_Variable, "Extract veriable from rigidbody object.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1120);
addNodeObject(rigidSim, "Rigidbody Override", Node_Rigid_Override, "Replace rigidbody object variable with a new one.")
.setIO(VALUE_TYPE.rigid).hideRecent().setVersion(1120);
#endregion
#region smokeSim
var smokeSim = ds_list_create();
NODE_ADD_CAT("SmokeSim", smokeSim, ["Node_Smoke_Group", "Node_Smoke_Group_Inline"], COLORS.node_blend_smoke);
ds_list_add(smokeSim, "Group");
addNodeObject(smokeSim, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(smokeSim, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(smokeSim, "Render Domain", Node_Smoke_Render_Output)
.setIO(VALUE_TYPE.sdomain, VALUE_TYPE.surface).hideRecent().setVersion(11540).hideGlobal();
ds_list_add(smokeSim, "Domain");
addNodeObject(smokeSim, "Domain", Node_Smoke_Domain)
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Update Domain", Node_Smoke_Update, "Run smoke by one step.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Render Domain", Node_Smoke_Render, "Render smoke to surface. This node also have update function build in.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Queue Domain", Node_Smoke_Domain_Queue, "Sync multiple domains to be render at the same time.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
ds_list_add(smokeSim, "Smoke");
addNodeObject(smokeSim, "Add Emitter", Node_Smoke_Add, "Add smoke emitter.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Apply Velocity", Node_Smoke_Apply_Velocity, "Apply velocity to smoke.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Add Collider", Node_Smoke_Add_Collider, "Add solid object that smoke can collides to.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Vortex", Node_Smoke_Vortex, "Apply rotational force around a point.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Repulse", Node_Smoke_Repulse, "Spread smoke away from a point.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
addNodeObject(smokeSim, "Turbulence", Node_Smoke_Turbulence, "Apply random velocity map to the smoke.")
.setIO(VALUE_TYPE.sdomain).hideRecent().setVersion(1120);
#endregion
#region flipSim
var flipSim = ds_list_create();
NODE_ADD_CAT("FLIP Fluid", flipSim, ["Node_FLIP_Group_Inline"], COLORS.node_blend_fluid);
ds_list_add(flipSim, "Domain");
addNodeObject(flipSim, "Domain", Node_FLIP_Domain)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11620);
addNodeObject(flipSim, "Render", Node_FLIP_Render)
.setIO(VALUE_TYPE.fdomain, VALUE_TYPE.surface).hideRecent().setVersion(11620);
addNodeObject(flipSim, "Update", Node_FLIP_Update)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11620);
ds_list_add(flipSim, "Fluid");
addNodeObject(flipSim, "Spawner", Node_FLIP_Spawner)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11620);
addNodeObject(flipSim, "Destroy", Node_FLIP_Destroy)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11680);
ds_list_add(flipSim, "Affectors");
addNodeObject(flipSim, "Apply Velocity", Node_FLIP_Apply_Velocity)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11620);
addNodeObject(flipSim, "Add Collider", Node_FLIP_Apply_Force)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11620);
//addNodeObject(flipSim, "Add Rigidbody", Node_FLIP_Add_Rigidbody).hideRecent().setVersion(11680);
addNodeObject(flipSim, "Repel", Node_FLIP_Repel)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11680);
addNodeObject(flipSim, "Vortex", Node_FLIP_Vortex)
.setIO(VALUE_TYPE.fdomain).hideRecent().setVersion(11680);
ds_list_add(flipSim, "Misc");
addNodeObject(flipSim, "FLIP to VFX", Node_FLIP_to_VFX)
.setIO(VALUE_TYPE.fdomain, VALUE_TYPE.particle).hideRecent().setVersion(11680);
#endregion
#region strandSim
var strandSim = ds_list_create();
NODE_ADD_CAT("StrandSim", strandSim, ["Node_Strand_Group", "Node_Strand_Group_Inline"], COLORS.node_blend_strand);
ds_list_add(strandSim, "Group");
addNodeObject(strandSim, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
addNodeObject(strandSim, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent().hideGlobal();
ds_list_add(strandSim, "System");
addNodeObject(strandSim, "Strand Create", Node_Strand_Create, "Create strands from point, path, or mesh.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Update", Node_Strand_Update, "Update strands by one step.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Render", Node_Strand_Render, "Render strands to surface as a single path.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Render Texture", Node_Strand_Render_Texture, "Render strands to surface as a textured path.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
ds_list_add(strandSim, "Affectors");
addNodeObject(strandSim, "Strand Gravity", Node_Strand_Gravity, "Apply downward acceleration to strands.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Force Apply", Node_Strand_Force_Apply, "Apply general force to strands.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Break", Node_Strand_Break, "Detach strands from its origin.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Length Adjust", Node_Strand_Length_Adjust, "Adjust length of strands in area.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
addNodeObject(strandSim, "Strand Collision", Node_Strand_Collision, "Create solid object for strands to collides to.")
.setIO(VALUE_TYPE.strands).hideRecent().setVersion(1140);
#endregion
//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\
global.__startPage = ds_list_size(NODE_CATEGORY);
#region io
var input = ds_list_create();
addNodeCatagory("IO", input);
ds_list_add(input, "Images");
ds_list_add(input, "/Importers");
addNodeObject(input, "Image", Node_Image, "Load a single image from your computer.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Image);
addNodeObject(input, "Image GIF", Node_Image_gif, "Load animated .gif from your computer.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Image_gif);
addNodeObject(input, "Image Array", Node_Image_Sequence, "Load multiple images from your computer as array.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Image_Sequence);
addNodeObject(input, "Animation", Node_Image_Animated, "Load multiple images from your computer as animation.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Image_Animated);
addNodeObject(input, "SVG", Node_SVG, "Load a SVG file.")
.setIO(VALUE_TYPE.surface);
ds_list_add(input, "/Converters");
addNodeObject(input, "Splice Spritesheet", Node_Image_Sheet, "Cut up spritesheet into animation or image array.")
.setIO(VALUE_TYPE.surface);
addNodeObject(input, "Array to Anim", Node_Sequence_Anim, "Convert array of images into animation.")
.setIO(VALUE_TYPE.surface);
addNodeObject(input, "Cache Array", Node_Cache_Array)
if(!DEMO) {
ds_list_add(input, "/Exporters");
addNodeObject(input, "Export", Node_Export, "Export image to file(s).")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Export);
}
ds_list_add(input, "Canvas");
addNodeObject(input, "Canvas", Node_Canvas, "Draw on surface using brush, eraser, etc.")
.setIO(VALUE_TYPE.surface).setTags(["draw"]);
addNodeObject(input, "Canvas Group", Node_Canvas_Group, "Create a group that combines multiple canvas nodes a layers.")
.setIO(VALUE_TYPE.surface).setTags(["draw"]).setVersion(11740);
addNodeObject(input, "Active Canvas", Node_Active_Canvas, "Draw using parameterized brush.").setTags(["draw"])
.setIO(VALUE_TYPE.surface).setVersion(11570);
ds_list_add(input, "Tileset");
ds_list_add(input, "/Creators");
addNodeObject(input, "Tileset", Node_Tile_Tileset, "Create tileset object.")
.setIO(VALUE_TYPE.surface, VALUE_TYPE.tileset).setVersion(1_18_03_0);
addNodeObject(input, "Tile Drawer", Node_Tile_Drawer, "Draw using tileset.")
.setIO(VALUE_TYPE.surface, VALUE_TYPE.tileset).setVersion(1_18_03_0);
addNodeObject(input, "Tile Rule", Node_Tile_Rule, "Apply tileset rules.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
addNodeObject(input, "Convert to Tilemap", Node_Tile_Convert, "Convert color image to tile data.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
ds_list_add(input, "/Exporters");
addNodeObject(input, "Render Tilemap", Node_Tile_Render, "Render tilemap to image.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
addNodeObject(input, "Export Tilemap", Node_Tile_Tilemap_Export, "Export tilemap to file.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
ds_list_add(input, "Files");
addNodeObject(input, "Text File In", Node_Text_File_Read, "Load .txt in as text.")
.setIO(VALUE_TYPE.text).setTags(["txt"]).setVersion(1080);
addNodeObject(input, "Text File Out", Node_Text_File_Write, "Save text as a .txt file.")
.setIO(VALUE_TYPE.text).setTags(["txt"]).setVersion(1090);
addNodeObject(input, "CSV File In", Node_CSV_File_Read, "Load .csv as text, number array.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.float).setTags(["comma separated value"]).setVersion(1090);
addNodeObject(input, "CSV File Out", Node_CSV_File_Write, "Save array as .csv file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.float).setTags(["comma separated value"]).setVersion(1090);
addNodeObject(input, "JSON File In", Node_Json_File_Read, "Load .json file using keys.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.struct).setVersion(1090);
addNodeObject(input, "JSON File Out", Node_Json_File_Write, "Save data to .json file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.struct).setVersion(1090);
addNodeObject(input, "WAV File In", Node_WAV_File_Read, "Load wav audio file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.audioBit).setBuild(Node_create_WAV_File_Read).setVersion(1144);
addNodeObject(input, "WAV File Out", Node_WAV_File_Write, "Save wav audio file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.audioBit).setVersion(1145);
addNodeObject(input, "XML File In", Node_XML_File_Read, "Load xml file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.struct).setBuild(Node_create_XML_File_Read).setVersion(11720);
addNodeObject(input, "XML File Out", Node_XML_File_Write, "Write struct to xml file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.struct).setVersion(11720);
addNodeObject(input, "Byte File In", Node_Byte_File_Read, "Load any file to buffer.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.buffer).setVersion(11670);
addNodeObject(input, "Byte File Out", Node_Byte_File_Write, "Save buffer content to a file.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.buffer).setVersion(11670);
addNodeObject(input, "Directory Search", Node_Directory_Search, "Search for files in directory.")
.setIO(VALUE_TYPE.text).setBuild(Node_create_Directory_Search).setVersion(11710);
ds_list_add(input, "Aseprite");
addNodeObject(input, "ASE File In", Node_ASE_File_Read, "Load Aseprite file with support for layers, tags.")
.setBuild(Node_create_ASE_File_Read).setIO(VALUE_TYPE.surface).setVersion(1100);
addNodeObject(input, "ASE Layer", Node_ASE_layer, "Load Aseprite project file")
.setIO(VALUE_TYPE.surface).setVersion(1100);
addNodeObject(input, "ASE Tag", Node_ASE_Tag, "Read tag from ASE file.")
.setSpr(s_node_ase_layer).setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
ds_list_add(input, "External");
addNodeObject(input, "Websocket Receiver", Node_Websocket_Receiver, "Create websocket server to receive data from the network.")
.setVersion(1145);
addNodeObject(input, "Websocket Sender", Node_Websocket_Sender, "Create websocket server to send data to the network.")
.setVersion(1145);
addNodeObject(input, "Spout Sender", Node_Spout_Send, "Send surface through Spout.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(input, "MIDI In", Node_MIDI_In, "Receive MIDI message.")
.setVersion(11630).notTest();
addNodeObject(input, "HTTP", Node_HTTP_request, "Request data from the internet.")
.setVersion(11780);
ds_list_add(input, "Gamemaker");
addNodeObject(input, "GMRoom", Node_GMRoom).setSpr(s_gmroom).setVersion(1_18_04_1);
#endregion
#region transform
var transform = ds_list_create();
addNodeCatagory("Transform", transform);
ds_list_add(transform, "Transforms");
addNodeObject(transform, "Transform", Node_Transform, "Move, rotate, and scale image.")
.setIO(VALUE_TYPE.surface).setTags(["move", "rotate", "scale"]);
addNodeObject(transform, "Scale", Node_Scale, "Simple node for scaling image.")
.setIO(VALUE_TYPE.surface).setTags(["resize"]);
addNodeObject(transform, "Scale Algorithm", Node_Scale_Algo, "Scale image using pixel-art based scaling algorithms.")
.setBuild(Node_create_Scale_Algo).setIO(VALUE_TYPE.surface).setTags(["scale2x", "scale3x", "cleanedge"]);
addNodeObject(transform, "Flip", Node_Flip, "Flip image horizontally or vertically.")
.setIO(VALUE_TYPE.surface).setTags(["mirror"]);
addNodeObject(transform, "Offset", Node_Offset, "Shift image with tiling.")
.setIO(VALUE_TYPE.surface).setTags(["shift"]);
addNodeObject(transform, "Mirror", Node_Mirror, "Reflect the image along a reflection line.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(transform, "Polar Mirror", Node_Mirror_Polar, "Reflect the image along multiple reflection lines.")
.setIO(VALUE_TYPE.surface).setTags(["kaleidoscope"]).setVersion(1_18_06_2);
ds_list_add(transform, "Crops");
addNodeObject(transform, "Crop", Node_Crop, "Crop out image to create smaller ones.")
.setIO(VALUE_TYPE.surface);
addNodeObject(transform, "Crop Content", Node_Crop_Content, "Crop out empty pixel from the image.")
.setIO(VALUE_TYPE.surface);
ds_list_add(transform, "Warps");
addNodeObject(transform, "Warp", Node_Warp, "Warp image by freely moving the corners.")
.setIO(VALUE_TYPE.surface).setTags(["warp corner"]);
// addNodeObject(transform, "Perspective Warp",Node_Warp_Perspective, "Warp image by modifying perspective.").setTags(["warp perspective"]);
addNodeObject(transform, "Skew", Node_Skew, "Skew image horizontally, or vertically.")
.setIO(VALUE_TYPE.surface).setTags(["shear"]);
// addNodeObject(transform, "Grid Warp", Node_Grid_Warp, "Wrap image by modifying mesh lacttice.");
addNodeObject(transform, "Bend", Node_Bend, "Warp an image into a predefined shape.")
.setIO(VALUE_TYPE.surface).setVersion(11650);
addNodeObject(transform, "Mesh Warp", Node_Mesh_Warp, "Wrap image by converting it to mesh, and using control points.")
.setIO(VALUE_TYPE.surface);
addNodeObject(transform, "Polar", Node_Polar, "Convert image to polar coordinate.")
.setIO(VALUE_TYPE.surface);
addNodeObject(transform, "Area Warp", Node_Wrap_Area, "Wrap image to fit an area value.")
.setIO(VALUE_TYPE.surface);
ds_list_add(transform, "Others");
addNodeObject(transform, "Composite", Node_Composite, "Combine multiple images with controllable position, rotation, scale.")
.setIO(VALUE_TYPE.surface).setTags(["merge"]);
addNodeObject(transform, "Nine Slice", Node_9Slice, "Cut image into 3x3 parts, and scale/repeat only the middle part.")
.setIO(VALUE_TYPE.surface).setTags(["9 slice", "splice", "nine patch"]);
addNodeObject(transform, "Padding", Node_Padding, "Make image bigger by adding space in 4 directions.")
.setIO(VALUE_TYPE.surface);
addNodeObject(transform, "Tile Random", Node_Tile_Random, "Repeat images on a larger surface randomly.")
.setIO(VALUE_TYPE.surface).setVersion(11780);
#endregion
#region filter
var filter = ds_list_create();
addNodeCatagory("Filter", filter);
ds_list_add(filter, "Combines");
addNodeObject(filter, "Blend", Node_Blend, "Blend 2 images using different blend modes.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Blend).setTags(global.node_blend_keys);
addNodeObject(filter, "RGBA Combine", Node_Combine_RGB, "Combine 4 image in to one. Each image use to control RGBA channel.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(filter, "HSV Combine", Node_Combine_HSV, "Combine 4 image in to one. Each image use to control HSVA channel.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(filter, "Override Channel", Node_Override_Channel, "Replace RGBA value of one surface with another.")
.setIO(VALUE_TYPE.surface).setVersion(11640);
ds_list_add(filter, "Blurs");
ds_list_add(filter, "/Kernel-based");
addNodeObject(filter, "Blur", Node_Blur, "Blur image smoothly.")
.setIO(VALUE_TYPE.surface).setTags(["gaussian blur"]);
addNodeObject(filter, "Non-Uniform Blur", Node_Blur_Simple, "Blur image using simpler algorithm. Allowing for variable blur strength.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(filter, "Contrast Blur", Node_Blur_Contrast, "Blur only pixel of a similiar color.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Box Blur", Node_Blur_Box, "Blur pixel in square area uniformly.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_06_2);
addNodeObject(filter, "Shape Blur", Node_Blur_Shape, "Blur image using another image as blur map.")
.setIO(VALUE_TYPE.surface).setVersion(11650);
addNodeObject(filter, "High Pass", Node_High_Pass, "Apply high pass filter")
.setIO(VALUE_TYPE.surface).setTags(["sharpen"]).setVersion(1_18_01_0);
ds_list_add(filter, "/Linear");
addNodeObject(filter, "Directional Blur", Node_Blur_Directional, "Blur image given a direction.")
.setIO(VALUE_TYPE.surface).setTags(["motion blur"]);
addNodeObject(filter, "Slope Blur", Node_Blur_Slope, "Blur along a gradient of a slope map.")
.setIO(VALUE_TYPE.surface).setTags(["motion blur"]).setVersion(11640);
addNodeObject(filter, "Zoom Blur", Node_Blur_Zoom, "Blur image by zooming in/out from a mid point.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Radial Blur", Node_Blur_Radial, "Blur image by rotating around a mid point.")
.setIO(VALUE_TYPE.surface).setVersion(1110);
addNodeObject(filter, "Path Blur", Node_Blur_Path, "Blur pixel along path.")
.setIO(VALUE_TYPE.surface).setVersion(11750);
addNodeObject(filter, "Smear", Node_Smear, "Stretch out brighter pixel in one direction.")
.setIO(VALUE_TYPE.surface).setVersion(11670);
ds_list_add(filter, "/Non-Linear");
addNodeObject(filter, "Lens Blur", Node_Blur_Bokeh, "Create bokeh effect. Blur lighter color in a lens-like manner.")
.setIO(VALUE_TYPE.surface).setTags(["bokeh"]).setVersion(1110);
addNodeObject(filter, "Average", Node_Average, "Average color of every pixels in the image.")
.setIO(VALUE_TYPE.surface).setVersion(1110);
addNodeObject(filter, "Kuwahara", Node_Kuwahara, "Apply Kuwahara filter. Creating a watercolor-like effect.")
.setIO(VALUE_TYPE.surface).setVersion(11660);
addNodeObject(filter, "Brush", Node_Brush_Linear, "Apply brush effect.")
.setIO(VALUE_TYPE.surface).patreonExtra();
ds_list_add(filter, "Warps");
ds_list_add(filter, "/Effects");
addNodeObject(filter, "Mirror", Node_Mirror, "Reflect the image along a reflection line.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Polar Mirror", Node_Mirror_Polar, "Reflect the image around multiple radial reflection lines.");
addNodeObject(filter, "Twirl", Node_Twirl, "Twist the image around a mid point.")
.setIO(VALUE_TYPE.surface).setTags(["twist"]);
addNodeObject(filter, "Dilate", Node_Dilate, "Expand the image around a mid point.")
.setIO(VALUE_TYPE.surface).setTags(["inflate"]);
addNodeObject(filter, "Spherize", Node_Spherize, "Wrap a texture on to sphere.")
.setIO(VALUE_TYPE.surface).setVersion(11630);
addNodeObject(filter, "Displace", Node_Displace, "Distort image using another image as a map.")
.setIO(VALUE_TYPE.surface).setTags(["distort"]);
addNodeObject(filter, "Morph Surface", Node_Morph_Surface, "Morph pixel between two surfaces.")
.setIO(VALUE_TYPE.surface).setVersion(1141);
addNodeObject(filter, "Liquefy", Node_Liquefy, "Distort image using variety of tools.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_02_0);
ds_list_add(filter, "/Mappers");
addNodeObject(filter, "Texture Remap", Node_Texture_Remap, "Remap image using texture map. Where red channel control x position and green channel control y position.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Time Remap", Node_Time_Remap, "Remap image using texture as time map. Where brighter pixel in time map means using pixel from an older frame.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Shape Map", Node_Shape_Map, "Map image into shapes.")
.setIO(VALUE_TYPE.surface).setVersion(11660);
ds_list_add(filter, "Effects");
ds_list_add(filter, "/Basics");
addNodeObject(filter, "Outline", Node_Outline, "Add border to the image.")
.setIO(VALUE_TYPE.surface).setTags(["border"]);
addNodeObject(filter, "Glow", Node_Glow, "Apply glow to the border of the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Shadow", Node_Shadow, "Apply shadow behind the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Blobify", Node_Blobify, "Round off sharp corner in BW image by bluring and thresholding.")
.setIO(VALUE_TYPE.surface).setVersion(11650);
addNodeObject(filter, "SDF", Node_SDF, "Create signed distance field using jump flooding algorithm.")
.setIO(VALUE_TYPE.surface).setVersion(1130);
addNodeObject(filter, "Replace Image", Node_Surface_Replace, "Replace instances of an image with a new one.")
.setIO(VALUE_TYPE.surface).setTags(["image replace"]).setVersion(1140);
ds_list_add(filter, "/Post Processing");
addNodeObject(filter, "Bloom", Node_Bloom, "Apply bloom effect, blurring and brighten the bright part of the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Blend Edge", Node_Blend_Edge, "Blend the edges of an image to create tilable patterns.")
.setIO(VALUE_TYPE.surface).setVersion(11740);
addNodeObject(filter, "Chromatic Aberration", Node_Chromatic_Aberration, "Apply chromatic aberration effect to the image.");
addNodeObject(filter, "FXAA", Node_FXAA, "Apply fast approximate anti-aliasing to te image.")
.setIO(VALUE_TYPE.surface).setTags(["anti aliasing"]);
addNodeObject(filter, "Vignette", Node_Vignette, "Apply vignette effect to the border.")
.setIO(VALUE_TYPE.surface).setVersion(11630);
addNodeObject(filter, "JPEG", Node_JPEG, "Apply JPEG compression to the image.")
.setIO(VALUE_TYPE.surface).setVersion(11730);
addNodeObject(filter, "Grain", Node_Grain, "Add noise pattern to the image.")
.setIO(VALUE_TYPE.surface).setVersion(11770);
ds_list_add(filter, "/Convolutions");
addNodeObject(filter, "Convolution", Node_Convolution, "Apply convolution operation on each pixel using a custom 3x3 kernel.")
.setIO(VALUE_TYPE.surface).setTags(["kernel"]).setVersion(1090);
addNodeObject(filter, "Edge Detect", Node_Edge_Detect, "Edge detect by applying Sobel, Prewitt, or Laplacian kernel.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Local Analyze", Node_Local_Analyze, "Apply non-linear operation (minimum, maximum) on each pixel locally.")
.setIO(VALUE_TYPE.surface).setVersion(1110);
addNodeObject(filter, "Erode", Node_Erode, "Remove pixel that are close to the border of the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Round Corner", Node_Corner, "Round out sharp corner of the image.")
.setIO(VALUE_TYPE.surface).setVersion(1110);
ds_list_add(filter, "/Pixel Operations");
addNodeObject(filter, "Pixel Math", Node_Pixel_Math, "Apply mathematical operation directly on RGBA value.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Pixel_Math).setTags(global.node_math_keys).setVersion(1_18_02_0);
addNodeObject(filter, "Pixel Expand", Node_Atlas, "Replace transparent pixel with the closest non-transparent pixel.")
.setIO(VALUE_TYPE.surface).setTags(["atlas"]);
addNodeObject(filter, "Pixel Cloud", Node_Pixel_Cloud, "Displace each pixel of the image randomly.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Pixel Sort", Node_Pixel_Sort, "Sort pixel by brightness in horizontal, or vertial axis.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Shuffle", Node_Shuffle, "Shuffle image while keeping pixel colors.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_05_6);
ds_list_add(filter, "/Lights");
addNodeObject(filter, "2D Light", Node_2D_light, "Apply different shaped light on the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Cast Shadow", Node_Shadow_Cast, "Apply light that casts shadow.")
.setIO(VALUE_TYPE.surface).setTags(["raycast"]).setVersion(1100);
ds_list_add(filter, "/Animations");
addNodeObject(filter, "Interlace", Node_Interlaced, "Apply interlace effect to an image.")
.setIO(VALUE_TYPE.surface).setVersion(11760);
addNodeObject(filter, "Trail", Node_Trail, "Blend animation by filling in the pixel 'in-between' two or more frames.")
.setIO(VALUE_TYPE.surface).setVersion(1130);
ds_list_add(filter, "Colors");
ds_list_add(filter, "/Replacements");
addNodeObject(filter, "Replace Palette", Node_Color_replace, "Match image to a palette then remap it to another palette.")
.setIO(VALUE_TYPE.surface).setTags(["isolate colors", "select colors", "palette swap", "colors replace"]);
addNodeObject(filter, "Replace Colors", Node_Colors_Replace, "Replace selected colors with a new one.")
.setIO(VALUE_TYPE.surface).setTags(["isolate colors", "select color", "palette swap"]);
addNodeObject(filter, "Remove Color", Node_Color_Remove, "Remove color that match a palette.")
.setIO(VALUE_TYPE.surface).setTags(["delete color"]);
addNodeObject(filter, "Separate Color", Node_Color_Separate, "Generate array of surfaces for each color.")
.setIO(VALUE_TYPE.surface);
ds_list_add(filter, "/Colorizers");
addNodeObject(filter, "Colorize", Node_Colorize, "Map brightness of a pixel to a color from a gradient.")
.setIO(VALUE_TYPE.surface).setTags(["recolor"]);
addNodeObject(filter, "Posterize", Node_Posterize, "Reduce and remap color to match a palette.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Dither", Node_Dither, "Reduce color and use dithering to preserve original color.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Error Diffuse Dither", Node_Dither_Diffuse, "Dither image using error diffusion algorithm.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_05_1);
addNodeObject(filter, "Palette Shift", Node_Palette_Shift, "Shift the order of color in palette.")
.setIO(VALUE_TYPE.surface).setVersion(1147);
ds_list_add(filter, "/Conversions");
addNodeObject(filter, "BW", Node_BW, "Convert color image to black and white.")
.setIO(VALUE_TYPE.surface).setTags(["black and white"]);
addNodeObject(filter, "Greyscale", Node_Greyscale, "Convert color image to greyscale.")
.setIO(VALUE_TYPE.surface).setTags(["grayscale"]);
addNodeObject(filter, "RGBA Extract", Node_RGB_Channel, "Extract RGBA channel on an image, each channel becomes its own image.")
.setIO(VALUE_TYPE.surface).setTags(["channel extract"]);
addNodeObject(filter, "HSV Extract", Node_HSV_Channel, "Extract HSVA channel on an image, each channel becomes its own image.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(filter, "Alpha to Grey", Node_Alpha_Grey, "Convert alpha value into solid greyscale.")
.setIO(VALUE_TYPE.surface).setTags(["alpha to gray"]);
addNodeObject(filter, "Grey to Alpha", Node_Grey_Alpha, "Convert greyscale to alpha value.")
.setIO(VALUE_TYPE.surface).setTags(["gray to alpha"]);
ds_list_add(filter, "/Adjustments");
addNodeObject(filter, "Color Adjust", Node_Color_adjust, "Adjust brightness, contrast, hue, saturation, value, alpha, and blend image with color.")
.setIO(VALUE_TYPE.surface).setTags(["brightness", "contrast", "hue", "saturation", "value", "color blend", "alpha"]);
addNodeObject(filter, "Level", Node_Level, "Adjust brightness of an image by changing its brightness range.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Level Selector", Node_Level_Selector, "Isolate part of the image that falls in the selected brightness range.")
.setIO(VALUE_TYPE.surface);
addNodeObject(filter, "Curve", Node_Curve, "Adjust brightness of an image using curves.")
.setIO(VALUE_TYPE.surface).setVersion(1120);
addNodeObject(filter, "HSV Curve", Node_Curve_HSV, "Adjust hsv values of an image using curves.")
.setIO(VALUE_TYPE.surface).setVersion(11720);
addNodeObject(filter, "Invert", Node_Invert, "Invert color.")
.setIO(VALUE_TYPE.surface).setTags(["negate"]);
addNodeObject(filter, "Threshold", Node_Threshold, "Set a threshold where pixel darker will becomes black, and brighter to white. Also works with alpha.")
.setIO(VALUE_TYPE.surface).setVersion(1080);
addNodeObject(filter, "Alpha Cutoff", Node_Alpha_Cutoff, "Remove pixel with low alpha value.")
.setIO(VALUE_TYPE.surface).setTags(["remove alpha"]);
addNodeObject(filter, "Normalize", Node_Normalize, "Normalize image ranges (brightness, RGB channels) in to [0, 1] range.")
.setIO(VALUE_TYPE.surface).setVersion(11710);
addNodeObject(filter, "Gamma Map", Node_Gamma_Map, "Apply gamma approximation (pow(2.2)) to an image.")
.setIO(VALUE_TYPE.surface).setTags(["srgb"]).setVersion(11660);
addNodeObject(filter, "ACE", Node_Tonemap_ACE, "Apply ACE tonemapping.")
.setIO(VALUE_TYPE.surface).setVersion(11710);
ds_list_add(filter, "Fixes");
addNodeObject(filter, "De-Corner", Node_De_Corner, "Attempt to remove single pixel corner from the image.")
.setIO(VALUE_TYPE.surface).setTags(["decorner"]);
addNodeObject(filter, "De-Stray", Node_De_Stray, "Attempt to remove orphan pixel.")
.setIO(VALUE_TYPE.surface).setTags(["destray"]);
#endregion
#region d3d
var d3d = ds_list_create();
addNodeCatagory("3D", d3d);
ds_list_add(d3d, "2D Operations");
addNodeObject(d3d, "Transform 3D", Node_3D_Transform_Image, "Transform image in 3D space")
.setIO(VALUE_TYPE.surface).setTags(["3d transform"]).setVersion(11600);
addNodeObject(d3d, "Normal", Node_Normal, "Create normal map using greyscale value as height.")
.setIO(VALUE_TYPE.surface);
addNodeObject(d3d, "Normal Light", Node_Normal_Light, "Light up the image using normal mapping.")
.setIO(VALUE_TYPE.surface);
addNodeObject(d3d, "Bevel", Node_Bevel, "Apply 2D bevel on the image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(d3d, "Sprite Stack", Node_Sprite_Stack, "Create sprite stack either from repeating a single image or stacking different images using array.")
.setIO(VALUE_TYPE.surface);
addNodeObject(d3d, "Ambient Occlusion", Node_Ambient_Occlusion, "Apply simple 2D AO effect using height map.")
.setIO(VALUE_TYPE.surface).setTags(["ao"]).patreonExtra();
ds_list_add(d3d, "Scenes");
addNodeObject(d3d, "3D Camera", Node_3D_Camera, "Create 3D camera that render scene to surface.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.surface).setVersion(11510);
addNodeObject(d3d, "3D Camera Set", Node_3D_Camera_Set, "3D camera with built-in key and fill directional lights.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.surface).setVersion(11571);
addNodeObject(d3d, "3D Scene", Node_3D_Scene, "Combine multiple 3D objects into a single junction.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
ds_list_add(d3d, "Materials");
addNodeObject(d3d, "3D Material", Node_3D_Material, "Create 3D material with adjustable parameters.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.surface).setVersion(11510);
ds_list_add(d3d, "Meshes");
ds_list_add(d3d, "/Creators");
addNodeObject(d3d, "3D Object", Node_3D_Mesh_Obj, "Load .obj file from your computer as a 3D object.")
.setIO(VALUE_TYPE.d3Mesh).setBuild(Node_create_3D_Obj).setVersion(11510);
addNodeObject(d3d, "3D Plane", Node_3D_Mesh_Plane, "Put 2D image on a plane in 3D space.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D Cube", Node_3D_Mesh_Cube, "Create 3D cube mesh.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D Cylinder", Node_3D_Mesh_Cylinder, "Create 3D cylinder mesh")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D UV Sphere", Node_3D_Mesh_Sphere_UV, "Create 3D uv sphere mesh")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D Icosphere", Node_3D_Mesh_Sphere_Ico, "Create 3D icosphere mesh")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D Cone", Node_3D_Mesh_Cone, "Create 3D cone mesh")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "3D Torus", Node_3D_Mesh_Torus, "Create 3D torus mesh")
.setIO(VALUE_TYPE.d3Mesh).setVersion(1_18_01_0);
addNodeObject(d3d, "3D Terrain", Node_3D_Mesh_Terrain, "Create 3D terrain from height map.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.surface).setVersion(11560);
addNodeObject(d3d, "3D Wall Builder", Node_3D_Mesh_Wall_Builder, "Create 3D wall be extruding 2D path.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.pathnode).setVersion(1_18_01_0);
addNodeObject(d3d, "Surface Extrude", Node_3D_Mesh_Extrude, "Extrude 2D image into 3D object.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.surface).setVersion(11510);
addNodeObject(d3d, "Path Extrude", Node_3D_Mesh_Path_Extrude, "Extrude path into 3D object.")
.setIO(VALUE_TYPE.d3Mesh, VALUE_TYPE.pathnode).setVersion(11750);
ds_list_add(d3d, "/Exporters");
addNodeObject(d3d, "Mesh Export", Node_3D_Mesh_Export, "Export 3D mesh as .obj file")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11740);
addNodeObject(d3d, "Slice Stack", Node_3D_Mesh_Stack_Slice, "Slice 3D object into array of 2d images.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11750);
ds_list_add(d3d, "Light");
addNodeObject(d3d, "Directional Light", Node_3D_Light_Directional, "Create directional light directed at the origin point.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
addNodeObject(d3d, "Point Light", Node_3D_Light_Point, "Create point light to illuminate surrounding area.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
ds_list_add(d3d, "Modify");
ds_list_add(d3d, "/Meshes");
addNodeObject(d3d, "Transform", Node_3D_Transform, "Transform 3D object.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11570);
addNodeObject(d3d, "Transform Scene", Node_3D_Transform_Scene, "Transform 3D scene, accepts array of transformations for each objects.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11570);
addNodeObject(d3d, "Discretize vertex", Node_3D_Round_Vertex, "Round out vertex position to a specified step.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11560);
addNodeObject(d3d, "3D Displace", Node_3D_Displace, "Shift vertex of 3D mesh using 2D map.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(1_18_01_0);
addNodeObject(d3d, "3D Subdivide", Node_3D_Subdivide, "Subdivide faces in mesh.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(1_18_03_0);
ds_list_add(d3d, "/Instances");
addNodeObject(d3d, "3D Repeat", Node_3D_Repeat, "Repeat the same 3D mesh multiple times.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11510);
// addNodeObject(d3d, "3D Instancer", Node_3D_Instancer).setVersion(11560);
// addNodeObject(d3d, "3D Particle", Node_3D_Particle).setVersion(11560);
ds_list_add(d3d, "/Materials");
addNodeObject(d3d, "Set Material", Node_3D_Set_Material, "Replace mesh material with a new one.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11560);
addNodeObject(d3d, "UV Remap", Node_3D_UV_Remap, "Remap UV map using plane.")
.setIO(VALUE_TYPE.d3Mesh).setVersion(11570);
ds_list_add(d3d, "Points");
addNodeObject(d3d, "Point Affector", Node_3D_Point_Affector, "Generate array of 3D points interpolating between two values based on the distance.")
.setIO(VALUE_TYPE.float).setVersion(11570);
ds_list_add(d3d, "Ray Marching");
addNodeObject(d3d, "RM Primitive", Node_RM_Primitive, "Create SDF object.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_RM_Primitive).setTags(global.node_rm_primitive_keys).setVersion(11720);
addNodeObject(d3d, "RM Combine", Node_RM_Combine, "Combine 2 SDF objects using boolean operation.")
.setIO(VALUE_TYPE.surface).setTags(["ray marching", "rm boolean"]).setVersion(11740);
addNodeObject(d3d, "RM Render", Node_RM_Render, "Render SDF object.")
.setIO(VALUE_TYPE.surface).setTags(["ray marching"]).setVersion(11740);
addNodeObject(d3d, "RM Terrain", Node_RM_Terrain, "Generate SDF image from height map.")
.setIO(VALUE_TYPE.surface).setTags(["ray marching"]).setVersion(11720);
addNodeObject(d3d, "RM Cloud", Node_RM_Cloud, "Generate distance field cloud texture.")
.setIO(VALUE_TYPE.surface).patreonExtra();
#endregion
#region generator
var generator = ds_list_create();
addNodeCatagory("Generate", generator);
ds_list_add(generator, "Colors");
addNodeObject(generator, "Solid", Node_Solid, "Create image of a single color.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Draw Gradient", Node_Gradient, "Create image from gradient.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Draw 4 Points Gradient", Node_Gradient_Points, "Create image from 4 color points.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Sky", Node_Sky, "Generate sky texture using different model.")
.setIO(VALUE_TYPE.surface);
ds_list_add(generator, "Drawer");
addNodeObject(generator, "Draw Line", Node_Line, "Draw line on an image. Connect path data to it to draw line from path.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Draw Text", Node_Text, "Draw text on an image.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Draw Shape", Node_Shape, "Draw simple shapes using signed distance field.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Shape).setTags(global.node_shape_keys);
addNodeObject(generator, "Draw Shape Polygon", Node_Shape_Polygon, "Draw polygonal shapes.")
.setIO(VALUE_TYPE.surface).setVersion(1130);
addNodeObject(generator, "Draw Random Shape", Node_Random_Shape, "Generate random shape, use for testing purposes.")
.setIO(VALUE_TYPE.surface).setVersion(1147);
addNodeObject(generator, "Draw Bar / Graph", Node_Plot_Linear, "Plot graph or bar chart from array of number.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Plot_Linear).setTags(global.node_plot_linear_keys).setVersion(1144);
addNodeObject(generator, "Draw Path Profile", Node_Path_Profile, "Fill-in an area on one side of a path.")
.setIO(VALUE_TYPE.surface).setVersion(11660);
addNodeObject(generator, "Draw Cross Section", Node_Cross_Section, "Map the brightness of pixels on a linear axis into a surface.")
.setIO(VALUE_TYPE.surface).setVersion(11710);
addNodeObject(generator, "Interpret Number", Node_Interpret_Number, "Convert array of number into surface.")
.setIO(VALUE_TYPE.surface).setVersion(11530);
addNodeObject(generator, "Pixel Builder", Node_Pixel_Builder, "Will break, do not create. please. Why is it here??")
.setIO(VALUE_TYPE.surface).setVersion(11540);
addNodeObject(generator, "Tile Drawer", Node_Tile_Drawer, "Draw using tileset.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_03_0);
ds_list_add(generator, "Noises");
ds_list_add(generator, "/Basics");
addNodeObject(generator, "Noise", Node_Noise, "Generate white noise.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Perlin Noise", Node_Perlin, "Generate perlin noise.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Simplex Noise", Node_Noise_Simplex, "Generate simplex noise, similiar to perlin noise with better fidelity but non-tilable.")
.setIO(VALUE_TYPE.surface).setTags(["perlin"]).setVersion(1080);
addNodeObject(generator, "Cellular Noise", Node_Cellular, "Generate voronoi pattern.")
.setIO(VALUE_TYPE.surface).setTags(["voronoi", "worley"]);
addNodeObject(generator, "Anisotropic Noise", Node_Noise_Aniso, "Generate anisotropic noise.")
.setIO(VALUE_TYPE.surface);
// addNodeObject(generator, "Blue Noise", Node_Noise_Blue, "Generate blue noise texture").setVersion(1_18_06_2);
addNodeObject(generator, "Extra Perlins", Node_Perlin_Extra, "Random perlin noise made with different algorithms.")
.setIO(VALUE_TYPE.surface).setTags(["noise"]).patreonExtra();
addNodeObject(generator, "Extra Voronoi", Node_Voronoi_Extra, "Random voronoi noise made with different algorithms.")
.setIO(VALUE_TYPE.surface).setTags(["noise"]).patreonExtra();
ds_list_add(generator, "/Artistics");
addNodeObject(generator, "Fold Noise", Node_Fold_Noise, "Generate cloth fold noise")
.setIO(VALUE_TYPE.surface).setVersion(11650);
addNodeObject(generator, "Strand Noise", Node_Noise_Strand, "Generate random srtands noise.")
.setIO(VALUE_TYPE.surface).setVersion(11650);
addNodeObject(generator, "Gabor Noise", Node_Gabor_Noise, "Generate Gabor noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Shard Noise", Node_Shard_Noise, "Generate glass shard-looking noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Wavelet Noise", Node_Wavelet_Noise, "Generate wavelet noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Caustic", Node_Caustic, "Generate caustic noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Bubble Noise", Node_Noise_Bubble, "Generate bubble noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Flow Noise", Node_Flow_Noise, "Generate fluid flow noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Cristal Noise", Node_Noise_Cristal, "Generate Cristal noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Honeycomb Noise", Node_Honeycomb_Noise, "Generate honeycomb noise")
.setIO(VALUE_TYPE.surface).patreonExtra();
ds_list_add(generator, "Patterns");
ds_list_add(generator, "/Basics");
addNodeObject(generator, "Stripe", Node_Stripe, "Generate stripe pattern.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Zigzag", Node_Zigzag, "Generate zigzag pattern.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Checker", Node_Checker, "Generate checkerboard pattern.")
.setIO(VALUE_TYPE.surface);
ds_list_add(generator, "/Grids");
addNodeObject(generator, "Grid", Node_Grid, "Generate grid pattern.")
.setIO(VALUE_TYPE.surface).setTags(["tile", "mosaic"]);
addNodeObject(generator, "Triangular Grid", Node_Grid_Tri, "Generate triangular grid pattern.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Hexagonal Grid", Node_Grid_Hex, "Generate hexagonal grid pattern.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Pentagonal Grid", Node_Grid_Pentagonal, "Generate Pentagonal grid pattern.")
.setIO(VALUE_TYPE.surface).patreonExtra();
ds_list_add(generator, "/Tiles");
addNodeObject(generator, "Pytagorean Tile", Node_Pytagorean_Tile, "Generate Pytagorean tile pattern.")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Herringbone Tile", Node_Herringbone_Tile, "Generate Herringbone tile pattern.")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "Random Tile", Node_Random_Tile, "Generate Random tile pattern.")
.setIO(VALUE_TYPE.surface).patreonExtra();
ds_list_add(generator, "/Others");
addNodeObject(generator, "Box Pattern", Node_Box_Pattern, "Generate square-based patterns.")
.setIO(VALUE_TYPE.surface).setVersion(11750);
addNodeObject(generator, "Quasicrystal", Node_Quasicrystal, "Generate Quasicrystal pattern.")
.setIO(VALUE_TYPE.surface).setVersion(11660);
addNodeObject(generator, "Pixel Sampler", Node_Pixel_Sampler, "Map image on to each individual pixels of another image.")
.setIO(VALUE_TYPE.surface).setVersion(11730);
addNodeObject(generator, "Julia", Node_Julia_Set, "Generate Julia fractal.")
.setIO(VALUE_TYPE.surface).setVersion(1_18_05_6);
ds_list_add(generator, "Populate");
addNodeObject(generator, "Repeat", Node_Repeat, "Repeat image multiple times linearly, or in grid pattern.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Repeat).setTags(global.node_repeat_keys).setVersion(1100);
addNodeObject(generator, "Scatter", Node_Scatter, "Scatter image randomly multiple times.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Repeat Texture", Node_Repeat_Texture, "Repeat texture over larger surface without repeating patterns.")
.setIO(VALUE_TYPE.surface);
ds_list_add(generator, "Simulation");
addNodeObject(generator, "Particle", Node_Particle, "Generate particle effect.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "VFX", Node_VFX_Group_Inline, "Create VFX group, which generate particles that can be manipulated using different force nodes.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_vfx);
addNodeObject(generator, "RigidSim", Node_Rigid_Group_Inline, "Create group for rigidbody simulation.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_rigid).setVersion(1110);
addNodeObject(generator, "FLIP Fluid", Node_FLIP_Group_Inline, "Create group for fluid simulation.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_flip_group).setVersion(11620);
addNodeObject(generator, "SmokeSim", Node_Smoke_Group_Inline, "Create group for smoke simulation.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_smoke_group).setVersion(1120);
addNodeObject(generator, "StrandSim", Node_Strand_Group_Inline, "Create group for hair simulation.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_strand).setTags(["hair"]).setVersion(1140);
addNodeObject(generator, "Diffuse", Node_Diffuse, "Simulate diffusion like simulation.")
.setIO(VALUE_TYPE.surface).setVersion(11640);
addNodeObject(generator, "Reaction Diffusion", Node_RD, "Simulate reaction diffusion effect.")
.setIO(VALUE_TYPE.surface).setSpr(s_node_reaction_diffusion).setVersion(11630);
ds_list_add(generator, "Region");
addNodeObject(generator, "Separate Shape", Node_Seperate_Shape, "Separate disconnected pixel each into an image in an image array.")
.setIO(VALUE_TYPE.surface);
addNodeObject(generator, "Region Fill", Node_Region_Fill, "Fill connected pixel with colors.")
.setIO(VALUE_TYPE.surface).setVersion(1147);
addNodeObject(generator, "Flood Fill", Node_Flood_Fill, "Filled connected pixel given position and color.")
.setIO(VALUE_TYPE.surface).setVersion(1133);
ds_list_add(generator, "MK Effects");
addNodeObject(generator, "MK Rain", Node_MK_Rain, "Generate deterministic rain.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK GridBalls", Node_MK_GridBalls, "Generate controllable grid of spheres.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK GridFlip", Node_MK_GridFlip, "Generate controllable grid of planes.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK Saber", Node_MK_Saber, "Generate glowing saber from 2 points.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK Tile", Node_MK_Tile, "Generate game engines-ready tileset.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK Flag", Node_MK_Flag, "Generate waving flag.")
.setIO(VALUE_TYPE.surface).setVersion(11600);
addNodeObject(generator, "MK Brownian", Node_MK_Brownian, "Generate random particle.")
.setIO(VALUE_TYPE.surface).setVersion(11630);
addNodeObject(generator, "MK Fall", Node_MK_Fall, "Generate leaves falling effects.")
.setIO(VALUE_TYPE.surface).setTags(["Leaf", "Leaves"]).setVersion(11630);
addNodeObject(generator, "MK Blinker", Node_MK_Blinker, "Flicker regions of the selected colors randomly.")
.setIO(VALUE_TYPE.surface).setVersion(11630);
addNodeObject(generator, "MK Lens Flare", Node_MK_Flare, "Generate lens flare.")
.setIO(VALUE_TYPE.surface).setVersion(11630);
addNodeObject(generator, "MK Delay Machine", Node_MK_Delay_Machine, "Combines multiple frames of animation into one.")
.setIO(VALUE_TYPE.surface).setVersion(11680);
addNodeObject(generator, "MK Fracture", Node_MK_Fracture, "Deterministically fracture and image and apply basic physics.")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "MK Sparkle", Node_MK_Sparkle, "Generate random star animation.")
.setIO(VALUE_TYPE.surface).patreonExtra();
addNodeObject(generator, "MK Subpixel", Node_MK_Subpixel, "Apply subpixel filter on top of a surface.")
.setIO(VALUE_TYPE.surface).setVersion(1_17_11_0);
#endregion
#region compose
var compose = ds_list_create();
addNodeCatagory("Compose", compose);
ds_list_add(compose, "Composes");
addNodeObject(compose, "Blend", Node_Blend, "Combine 2 images using different blend modes.")
.setIO(VALUE_TYPE.surface);
addNodeObject(compose, "Composite", Node_Composite, "Combine multiple images with custom transformation.")
.setIO(VALUE_TYPE.surface);
addNodeObject(compose, "Stack", Node_Stack, "Place image next to each other linearly, or on top of each other.")
.setIO(VALUE_TYPE.surface).setVersion(1070);
addNodeObject(compose, "Image Grid", Node_Image_Grid, "Place image next to each other in grid pattern.")
.setIO(VALUE_TYPE.surface).setVersion(11640);
addNodeObject(compose, "Camera", Node_Camera, "Create camera that crop image to fix dimension with control of position, zoom. Also can be use to create parallax effect.")
.setIO(VALUE_TYPE.surface);
addNodeObject(compose, "Render Spritesheet", Node_Render_Sprite_Sheet, "Create spritesheet from image array or animation.")
.setIO(VALUE_TYPE.surface);
addNodeObject(compose, "Pack Sprites", Node_Pack_Sprites, "Combine array of images with different dimension using different algorithms.")
.setIO(VALUE_TYPE.surface).setVersion(1140);
ds_list_add(compose, "Armature");
ds_list_add(compose, "/Basics");
addNodeObject(compose, "Armature Create", Node_Armature, "Create new armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1146);
addNodeObject(compose, "Armature Pose", Node_Armature_Pose, "Pose armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1146);
addNodeObject(compose, "Armature Bind", Node_Armature_Bind, "Bind and render image to an armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1146);
addNodeObject(compose, "Armature Mesh Rig", Node_Armature_Mesh_Rig, "Rig mesh to armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1_18_04_0);
ds_list_add(compose, "/Convertors");
addNodeObject(compose, "Armature Path", Node_Armature_Path, "Generate path from armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1146);
addNodeObject(compose, "Armature Sample", Node_Armature_Sample, "Sample point from armature system.")
.setIO(VALUE_TYPE.surface).setTags(["rigging", "bone"]).setVersion(1147);
if(!DEMO) {
ds_list_add(compose, "Export");
addNodeObject(compose, "Export", Node_Export, "Export image/animation to file(s).")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Export);
}
#endregion
#region values
var values = ds_list_create();
addNodeCatagory("Values", values);
ds_list_add(values, "Raw data");
addNodeObject(values, "Number", Node_Number, "Generate number data.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Boolean", Node_Boolean, "Generate boolean (true, false) data.")
.setIO(VALUE_TYPE.boolean).setVersion(1090);
addNodeObject(values, "Text", Node_String, "Generate text/string data.")
.setIO(VALUE_TYPE.text);
addNodeObject(values, "Path", Node_Path, "Generate path.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Area", Node_Area, "Generate area data.")
.setIO(VALUE_TYPE.float);
ds_list_add(values, "Numbers");
ds_list_add(values, "/Creators");
addNodeObject(values, "Number", Node_Number, "Generate number data.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "To Number", Node_To_Number, "Convert string to number, supports scientific format (e.g. 1e-2 = 0.02).")
.setIO(VALUE_TYPE.float).setVersion(1145);
addNodeObject(values, "Random", Node_Random, "Generate pseudo-random value based on seed.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Scatter Points", Node_Scatter_Points, "Generate array of vector 2 points.")
.setIO(VALUE_TYPE.float).setVersion(1120);
addNodeObject(values, "Transform Array", Node_Transform_Array, "Generate transfomation array.")
.setIO(VALUE_TYPE.float).setVersion(1146);
ds_list_add(values, "/Operators");
addNodeObject(values, "Math", Node_Math, "Apply mathematical function to number(s).")
.setIO(VALUE_TYPE.float).setBuild(Node_create_Math).setTags(global.node_math_keys);
addNodeObject(values, "Equation", Node_Equation, "Evaluate string of equation. With an option for setting variables.")
.setIO(VALUE_TYPE.float).setBuild(Node_create_Equation);
addNodeObject(values, "Statistic", Node_Statistic, "Apply statistical operation (sum, average, median, etc.) to array of numbers.")
.setIO(VALUE_TYPE.float).setBuild(Node_create_Statistic).setTags(global.node_statistic_keys);
addNodeObject(values, "Convert Base", Node_Base_Convert, "Convert number from one base to another.")
.setIO(VALUE_TYPE.float).setTags(["binary", "hexadecimal"]).setVersion(1140);
addNodeObject(values, "FFT", Node_FFT, "Perform fourier transform on number array.")
.setIO(VALUE_TYPE.float).setTags(["frequency analysis"]).setVersion(1144);
ds_list_add(values, "Vector");
ds_list_add(values, "/Creators");
addNodeObject(values, "Vector2", Node_Vector2, "Genearte vector composite of 2 members.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Vector3", Node_Vector3, "Genearte vector composite of 3 members.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Vector4", Node_Vector4, "Genearte vector composite of 4 members.")
.setIO(VALUE_TYPE.float);
ds_list_add(values, "/Components");
addNodeObject(values, "Vector Split", Node_Vector_Split, "Split vector (up to 4) into individual components.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Swizzle", Node_Vector_Swizzle, "Rearrange vector using string containing axis indicies (x, y, z, w).")
.setIO(VALUE_TYPE.float).setTags(["swap axis"]).setVersion(1_17_10_0);
ds_list_add(values, "/Operators");
addNodeObject(values, "Magnitude", Node_Vector_Magnitude, "Calculate magnitude (length) of a vector.")
.setIO(VALUE_TYPE.float).setTags(["vector length", "vector magnitude"]).setVersion(1_17_10_0);
addNodeObject(values, "Dot product", Node_Vector_Dot, "Calculate dot product between vectors.")
.setIO(VALUE_TYPE.float).setVersion(1141);
addNodeObject(values, "Cross product 2D", Node_Vector_Cross_2D, "Calculate cross product of 2 vec2s.")
.setIO(VALUE_TYPE.float).setVersion(1141);
addNodeObject(values, "Cross product 3D", Node_Vector_Cross_3D, "Calculate cross product of 2 vec3s.")
.setIO(VALUE_TYPE.float).setVersion(1141);
ds_list_add(values, "/Points");
addNodeObject(values, "Translate Point", Node_Move_Point, "Translate array of points.")
.setIO(VALUE_TYPE.float).setVersion(1141);
addNodeObject(values, "Point in Area", Node_Point_In_Area, "Check whether a point lies in an area.")
.setIO(VALUE_TYPE.float).setVersion(1_17_10_0);
ds_list_add(values, "Texts");
ds_list_add(values, "/Creators");
addNodeObject(values, "Text", Node_String, "Generate text/string data.")
.setIO(VALUE_TYPE.text);
addNodeObject(values, "To Text", Node_To_Text, "Convert string to number.")
.setIO(VALUE_TYPE.text).setVersion(1145);
addNodeObject(values, "Unicode", Node_Unicode, "Convert unicode id into string.")
.setIO(VALUE_TYPE.text);
ds_list_add(values, "/Info");
addNodeObject(values, "Text Length", Node_String_Length, "Return number of character in a string.")
.setIO(VALUE_TYPE.text, VALUE_TYPE.float).setVersion(1138);
addNodeObject(values, "Get Character", Node_String_Get_Char, "Get a nth character in a string.")
.setIO(VALUE_TYPE.text).setVersion(1100);
ds_list_add(values, "/Operators");
addNodeObject(values, "Combine Texts", Node_String_Merge, "Combine multiple strings into one long string.")
.setIO(VALUE_TYPE.text).setTags(["join text", "concatenate text"]);
addNodeObject(values, "Join Text Array", Node_String_Join, "Combine string array with an option to add extra string in-between.")
.setIO(VALUE_TYPE.text).setVersion(1120);
addNodeObject(values, "Split Text", Node_String_Split, "Split string into arrays of substring based on delimiter.")
.setIO(VALUE_TYPE.text);
addNodeObject(values, "Trim Text", Node_String_Trim, "Remove first and last n character(s) from a string.")
.setIO(VALUE_TYPE.text).setVersion(1080);
ds_list_add(values, "/RegEx");
addNodeObject(values, "RegEx Match", Node_String_Regex_Match, "Check whether regular expression pattern exist in a string.")
.setIO(VALUE_TYPE.text).setVersion(1140);
addNodeObject(values, "RegEx Search", Node_String_Regex_Search, "Search for instances in a string using regular expression.")
.setIO(VALUE_TYPE.text).setVersion(1140);
addNodeObject(values, "RegEx Replace", Node_String_Regex_Replace, "Replace instances of a string with another using regular expression.")
.setIO(VALUE_TYPE.text).setVersion(1140);
ds_list_add(values, "/Filename");
addNodeObject(values, "Separate File Path", Node_Path_Separate_Folder, "Separate path string into a pair of directory and filename.")
.setIO(VALUE_TYPE.text).setVersion(1145);
ds_list_add(values, "Arrays");
ds_list_add(values, "/Creators");
addNodeObject(values, "Array", Node_Array, "Create an array.")
.setIO(VALUE_TYPE.any);
addNodeObject(values, "Array Range", Node_Array_Range, "Create array of numbers by setting start, end and step length.")
.setIO(VALUE_TYPE.float);
addNodeObject(values, "Parse CSV", Node_Array_CSV_Parse, "Parse CSV string into array.")
.setIO(VALUE_TYPE.text).setVersion(1145);
ds_list_add(values, "/Info");
addNodeObject(values, "Array Length", Node_Array_Length, "Returns number of members in an array.")
.setIO(VALUE_TYPE.any);
addNodeObject(values, "Array Get", Node_Array_Get, "Returns nth member in an array.")
.setIO(VALUE_TYPE.any);
addNodeObject(values, "Array Sample", Node_Array_Sample, "Sample member from an array to create smaller one.")
.setIO(VALUE_TYPE.any).setVersion(11540);
addNodeObject(values, "Array Find", Node_Array_Find, "Returns index of an array member that match a condition.")
.setIO(VALUE_TYPE.any).setVersion(1120);
ds_list_add(values, "/Operators");
addNodeObject(values, "Array Set", Node_Array_Set, "Set array member based on index.")
.setIO(VALUE_TYPE.any).setVersion(1120);
addNodeObject(values, "Array Add", Node_Array_Add, "Add elements into an array.")
.setIO(VALUE_TYPE.any);
addNodeObject(values, "Array Split", Node_Array_Split, "Split array members into individual outputs.")
.setIO(VALUE_TYPE.any);
addNodeObject(values, "Array Insert", Node_Array_Insert, "Insert member into an array at any position.")
.setIO(VALUE_TYPE.any).setVersion(1120);
addNodeObject(values, "Array Remove", Node_Array_Remove, "Remove member in an array.")
.setIO(VALUE_TYPE.any).setTags(["delete array"]).setVersion(1120);
addNodeObject(values, "Array Reverse", Node_Array_Reverse, "Reverse array order")
.setIO(VALUE_TYPE.any).setVersion(1120);
addNodeObject(values, "Array Shift", Node_Array_Shift, "Shift all member in an array.")
.setIO(VALUE_TYPE.any).setVersion(1137);
addNodeObject(values, "Array Rearrange", Node_Array_Rearrange, "Rearrange array member manually.")
.setIO(VALUE_TYPE.any).setVersion(11640);
addNodeObject(values, "Array Zip", Node_Array_Zip, "Combine multiple arrays into higher dimension array by grouping member of the same indicies.")
.setIO(VALUE_TYPE.any).setVersion(1138);
addNodeObject(values, "Array Copy", Node_Array_Copy, "Copy array or subarray.")
.setIO(VALUE_TYPE.any).setVersion(1144);
addNodeObject(values, "Array Convolute", Node_Array_Convolute, "Apply convolution between 2 number arrays.")
.setIO(VALUE_TYPE.any).setVersion(11540);
addNodeObject(values, "Array Composite", Node_Array_Composite, "Create 2D array by multiplying each member in the first 1D array with the second 1D array.")
.setIO(VALUE_TYPE.any).setVersion(11540);
addNodeObject(values, "Shuffle Array", Node_Array_Shuffle, "Randomly rearrange the array members.")
.setIO(VALUE_TYPE.any).setVersion(1120);
ds_list_add(values, "/Group Operators");
addNodeObject(values, "Sort Array", Node_Array_Sort, "Sort array using default comparison.")
.setIO(VALUE_TYPE.any).setVersion(1120);
addNodeObject(values, "Loop Array", Node_Iterate_Each_Inline, "Create group that iterate to each member in an array.")
.setIO(VALUE_TYPE.any).setSpr(s_node_loop_array).setTags(["iterate each", "for each"]);
addNodeObject(values, "Filter Array", Node_Iterate_Filter_Inline, "Filter array using condition.")
.setIO(VALUE_TYPE.any).setSpr(s_node_filter_array).setVersion(1140);
addNodeObject(values, "Sort Array Inline", Node_Iterate_Sort_Inline, "Sort array using node graph.")
.setIO(VALUE_TYPE.any).setSpr(s_node_sort_array).setVersion(1143);
ds_list_add(values, "Paths");
ds_list_add(values, "/Creators");
addNodeObject(values, "Path", Node_Path, "Create path using bezier curve.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.float);
addNodeObject(values, "Smooth Path", Node_Path_Smooth, "Create path with automatic smoothness.")
.setIO(VALUE_TYPE.pathnode).setVersion(11640);
addNodeObject(values, "Shape Path", Node_Path_Shape, "Create path with predefined shape.")
.setIO(VALUE_TYPE.pathnode).setVersion(1_18_05_6);
addNodeObject(values, "Path Builder", Node_Path_Builder, "Create path from array of vec2 points.")
.setIO(VALUE_TYPE.pathnode).setVersion(1137);
addNodeObject(values, "L system", Node_Path_L_System, "Generate path using Lindenmayer system.")
.setIO(VALUE_TYPE.pathnode).setVersion(1137);
addNodeObject(values, "Path from Mask", Node_Path_From_Mask, "Create path that wrap around a mask.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.surface).setVersion(11640);
addNodeObject(values, "Plot Path", Node_Path_Plot, "Create path from parametric equations.")
.setIO(VALUE_TYPE.pathnode).setVersion(1138);
addNodeObject(values, "3D Path", Node_Path_3D, "Create path in 3D space.")
.setIO(VALUE_TYPE.pathnode).setVersion(11750);
addNodeObject(values, "Path Anchor", Node_Path_Anchor, "Create path anchor data.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.float).setVersion(1140);
ds_list_add(values, "/Modifiers");
addNodeObject(values, "Transform Path", Node_Path_Transform, "Move rotate and scale a path.")
.setIO(VALUE_TYPE.pathnode).setVersion(1130);
addNodeObject(values, "Remap Path", Node_Path_Map_Area, "Scale path to fit a given area.")
.setIO(VALUE_TYPE.pathnode).setVersion(1130);
addNodeObject(values, "Shift Path", Node_Path_Shift, "Move path along its normal.")
.setIO(VALUE_TYPE.pathnode).setVersion(1130);
addNodeObject(values, "Trim Path", Node_Path_Trim, "Trim path.")
.setIO(VALUE_TYPE.pathnode).setVersion(1130);
addNodeObject(values, "Wave Path", Node_Path_Wave, "Apply wave effect along the path.")
.setIO(VALUE_TYPE.pathnode).setTags(["zigzag path"]).setVersion(1130);
addNodeObject(values, "Path Combine", Node_Path_Array, "Combine multiple path into one.")
.setIO(VALUE_TYPE.pathnode).setTags(["array path"]).setVersion(1137);
addNodeObject(values, "Reverse Path", Node_Path_Reverse, "Reverse path direction.")
.setIO(VALUE_TYPE.pathnode).setVersion(1130);
ds_list_add(values, "/Combine");
addNodeObject(values, "Repeat Path", Node_Path_Repeat, "Repeat paths.")
.setIO(VALUE_TYPE.pathnode).setVersion(1_18_05_6);
addNodeObject(values, "Scatter Path", Node_Path_Scatter, "Scatter paths along another path.")
.setIO(VALUE_TYPE.pathnode).setVersion(11740);
addNodeObject(values, "Bridge Path", Node_Path_Bridge, "Create new paths that connect multiple paths at the same sample positions.")
.setIO(VALUE_TYPE.pathnode).setVersion(11640);
addNodeObject(values, "Blend Path", Node_Path_Blend, "Blend between 2 paths.")
.setIO(VALUE_TYPE.pathnode);
ds_list_add(values, "/To Number");
addNodeObject(values, "Sample Path", Node_Path_Sample, "Sample a 2D position from a path")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.float);
addNodeObject(values, "Bake Path", Node_Path_Bake, "Bake path data into array of vec2 points.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.float).setVersion(11640);
ds_list_add(values, "/To Surface");
addNodeObject(values, "Fill Path", Node_Path_Fill, "Fill area inside path.")
.setIO(VALUE_TYPE.float).setVersion(1_18_06_2);
addNodeObject(values, "Map Path", Node_Path_Map, "Map a texture between multiple paths.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.surface).setVersion(11640);
addNodeObject(values, "Morph Path", Node_Path_Morph, "Draw gradient connecting 2 paths.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.surface).setVersion(1_18_06_2);
ds_list_add(values, "/Segments");
addNodeObject(values, "Filter Segments", Node_Segment_Filter, "Filter segment (vec2 array) based on a conditions.")
.setIO(VALUE_TYPE.float).setVersion(11780);
ds_list_add(values, "Boolean");
addNodeObject(values, "Boolean", Node_Boolean)
.setIO(VALUE_TYPE.boolean);
addNodeObject(values, "Compare", Node_Compare, "Compare 2 numbers.")
.setIO(VALUE_TYPE.boolean, VALUE_TYPE.float).setBuild(Node_create_Compare).setTags(global.node_compare_keys);
addNodeObject(values, "Logic Opr", Node_Logic, "Apply logic operation (and, or, not, etc.) to boolean(s).")
.setIO(VALUE_TYPE.boolean, VALUE_TYPE.float).setBuild(Node_create_Logic).setTags(global.node_logic_keys);
ds_list_add(values, "Trigger");
addNodeObject(values, "Trigger", Node_Trigger, "Create trigger value.")
.setIO(VALUE_TYPE.boolean, VALUE_TYPE.trigger).setVersion(1140);
addNodeObject(values, "Boolean Trigger", Node_Trigger_Bool, "Create trigger based on boolean condition.")
.setIO(VALUE_TYPE.boolean, VALUE_TYPE.trigger).setVersion(1140);
ds_list_add(values, "Struct");
addNodeObject(values, "Struct", Node_Struct, "Create key-value pair struct.")
.setIO(VALUE_TYPE.struct);
addNodeObject(values, "Struct Get", Node_Struct_Get, "Get value from struct and key.")
.setIO(VALUE_TYPE.struct);
addNodeObject(values, "Struct Set", Node_Struct_Set, "Modify struct")
.setIO(VALUE_TYPE.struct);
addNodeObject(values, "Parse JSON", Node_Struct_JSON_Parse, "Parse json string into struct/array.")
.setIO(VALUE_TYPE.struct, VALUE_TYPE.text).setVersion(1145);
ds_list_add(values, "Mesh");
addNodeObject(values, "Path to Mesh", Node_Mesh_Create_Path, "Create mesh from path.")
.setIO(VALUE_TYPE.pathnode, VALUE_TYPE.mesh).setVersion(1140);
addNodeObject(values, "Mesh Transform", Node_Mesh_Transform, "Transform (move, rotate, scale) mesh.")
.setIO(VALUE_TYPE.mesh).setVersion(1140);
ds_list_add(values, "Atlas");
addNodeObject(values, "Draw Atlas", Node_Atlas_Draw, "Render image atlas to a surface.")
.setIO(VALUE_TYPE.surface).setVersion(1141);
addNodeObject(values, "Atlas Get", Node_Atlas_Get, "Extract atlas data.")
.setIO(VALUE_TYPE.surface).setVersion(1141);
addNodeObject(values, "Atlas Set", Node_Atlas_Set, "Modify atlas data.")
.setIO(VALUE_TYPE.surface).setVersion(1141);
addNodeObject(values, "Atlas to Struct", Node_Atlas_Struct, "Convert atlas into generic struct.")
.setIO(VALUE_TYPE.surface).setVersion(11710);
ds_list_add(values, "Surface");
addNodeObject(values, "Surface Data", Node_Surface_data, "Extract information about a surface")
.setIO(VALUE_TYPE.surface).setTags(["surface info"]).setVersion(1_18_07_0);
// addNodeObject(values, "Dynamic Surface", Node_dynaSurf).setVersion(11520);
addNodeObject(values, "IsoSurf", Node_IsoSurf, "Create a dynamic surface that changes its texture based on rotation.")
.setIO(VALUE_TYPE.surface).setVersion(11520);
addNodeObject(values, "Surface from Buffer", Node_Surface_From_Buffer, "Create surface from a valid buffer.")
.setIO(VALUE_TYPE.surface, VALUE_TYPE.buffer).setTags(["buffer to surface"]).setVersion(1146);
ds_list_add(values, "Buffer");
addNodeObject(values, "Buffer from Surface", Node_Surface_To_Buffer, "Create buffer from a surface.")
.setIO(VALUE_TYPE.surface, VALUE_TYPE.buffer).setTags(["surface to buffer"]).setVersion(1146);
#endregion
#region color
var color = ds_list_create();
addNodeCatagory("Color", color);
ds_list_add(color, "Colors");
ds_list_add(color, "/Creators");
addNodeObject(color, "Color", Node_Color, "Create color value.")
.setIO(VALUE_TYPE.color).setSpr(s_node_color_out);
addNodeObject(color, "RGB Color", Node_Color_RGB, "Create (rgb) color from value in RGB color space.")
.setIO(VALUE_TYPE.color).setSpr(s_node_color_from_rgb);
addNodeObject(color, "HSV Color", Node_Color_HSV, "Create (rgb) color from value in HSV color space.")
.setIO(VALUE_TYPE.color).setSpr(s_node_color_from_hsv);
addNodeObject(color, "OKLCH Color", Node_Color_OKLCH, "Create (rgb) color from value in OKLCH color space.")
.setIO(VALUE_TYPE.color).setSpr(s_node_color_from_oklch).setTags(["oklab"]);
ds_list_add(color, "/Data");
addNodeObject(color, "Color Data", Node_Color_Data, "Get data (rgb, hsv, brightness) from color.")
.setIO(VALUE_TYPE.color).setTags(["red", "green", "blue", "alpha", "brightness", "luminance"]);
ds_list_add(color, "/Operators");
addNodeObject(color, "Mix Color", Node_Color_Mix, "Combine two colors.")
.setIO(VALUE_TYPE.color).setVersion(1140);
ds_list_add(color, "/Surfaces");
addNodeObject(color, "Sampler", Node_Sampler, "Sample color from an image.")
.setIO(VALUE_TYPE.color, VALUE_TYPE.surface);
addNodeObject(color, "Find pixel", Node_Find_Pixel, "Get the position of the first pixel with a given color.")
.setIO(VALUE_TYPE.color, VALUE_TYPE.surface, VALUE_TYPE.float).setVersion(1130);
ds_list_add(color, "Palettes");
addNodeObject(color, "Palette", Node_Palette, "Create palette value. Note that palette is simple an array of colors.")
.setIO(VALUE_TYPE.color);
addNodeObject(color, "Sort Palette", Node_Palette_Sort, "Sort palette with specified order.")
.setIO(VALUE_TYPE.color).setVersion(1130);
addNodeObject(color, "Shrink Palette", Node_Palette_Shrink, "Reduce palette size by collapsing similiar colors.")
.setIO(VALUE_TYPE.color).setVersion(1_18_03_0);
addNodeObject(color, "Palette Extract", Node_Palette_Extract, "Extract palette from an image.")
.setIO(VALUE_TYPE.color).setVersion(1100);
addNodeObject(color, "Palette Replace", Node_Palette_Replace, "Replace colors in a palette with new one.")
.setIO(VALUE_TYPE.color).setVersion(1120);
ds_list_add(color, "Gradient");
addNodeObject(color, "Gradient", Node_Gradient_Out, "Create gradient object")
.setIO(VALUE_TYPE.gradient);
addNodeObject(color, "Palette to Gradient", Node_Gradient_Palette, "Create gradient from palette.")
.setIO(VALUE_TYPE.gradient).setVersion(1135);
addNodeObject(color, "Gradient Shift", Node_Gradient_Shift, "Move gradients keys.")
.setIO(VALUE_TYPE.gradient);
addNodeObject(color, "Gradient Replace", Node_Gradient_Replace_Color, "Replace color inside a gradient.")
.setIO(VALUE_TYPE.gradient).setVersion(1135);
addNodeObject(color, "Gradient Data", Node_Gradient_Extract, "Get palatte and array of key positions from gradient.")
.setIO(VALUE_TYPE.gradient).setVersion(1135);
addNodeObject(color, "Sample Gradient", Node_Gradient_Sample, "Sample gradient into palette.")
.setIO(VALUE_TYPE.gradient, VALUE_TYPE.particle).setVersion(1_18_04_1);
#endregion
#region animation
var animation = ds_list_create();
addNodeCatagory("Animation", animation);
ds_list_add(animation, "Animations");
addNodeObject(animation, "Frame Index", Node_Counter, "Output current frame as frame index, or animation progress (0 - 1).")
.setIO(VALUE_TYPE.float).setTags(["current frame", "counter"]);
addNodeObject(animation, "Rate Remap", Node_Rate_Remap, "Remap animation to a new framerate.")
.setIO(VALUE_TYPE.surface).setVersion(1147);
addNodeObject(animation, "Delay", Node_Delay, "Delay the animation by fix amount of frames.")
.setIO(VALUE_TYPE.surface).setVersion(11640);
addNodeObject(animation, "Stagger", Node_Stagger, "Delay the animation based on array index.")
.setIO(VALUE_TYPE.surface).setVersion(11640);
addNodeObject(animation, "Reverse", Node_Revert, "Cache the entire animation and replay backward.")
.setIO(VALUE_TYPE.surface).setVersion(1_17_11_0);
ds_list_add(animation, "Value");
addNodeObject(animation, "Evaluate Curve", Node_Anim_Curve, "Evaluate value from an animation curve.")
.setIO(VALUE_TYPE.float);
addNodeObject(animation, "WaveTable", Node_Fn_WaveTable, "Create value changing overtime in wave pattern.")
.setIO(VALUE_TYPE.float).setVersion(11720);
addNodeObject(animation, "Wiggler", Node_Wiggler, "Create random value smoothly changing over time.")
.setIO(VALUE_TYPE.float);
addNodeObject(animation, "Ease", Node_Fn_Ease, "Create easing function.")
.setIO(VALUE_TYPE.float).setVersion(11720);
addNodeObject(animation, "Math", Node_Fn_Math, "Apply mathematic operation of wave value.")
.setIO(VALUE_TYPE.float).setVersion(11720);
addNodeObject(animation, "SmoothStep", Node_Fn_SmoothStep, "Apply smoothstop function to a value.")
.setIO(VALUE_TYPE.float).setVersion(11720);
ds_list_add(animation, "Audio");
ds_list_add(animation, "/Files");
addNodeObject(animation, "WAV File In", Node_WAV_File_Read, "Load wav audio file.")
.setIO(VALUE_TYPE.audioBit, VALUE_TYPE.text).setBuild(Node_create_WAV_File_Read).setVersion(1144);
addNodeObject(animation, "WAV File Out", Node_WAV_File_Write, "Save wav audio file.")
.setIO(VALUE_TYPE.audioBit, VALUE_TYPE.text).setVersion(1145);
ds_list_add(animation, "/Analyzers");
addNodeObject(animation, "Audio Window", Node_Audio_Window, "Take a slice of an audio array based on the current frame.")
.setIO(VALUE_TYPE.audioBit, VALUE_TYPE.float).setVersion(1144);
addNodeObject(animation, "Audio Volume", Node_Audio_Loudness, "Calculate volume of an audio bit array.")
.setIO(VALUE_TYPE.audioBit, VALUE_TYPE.float).setVersion(11540);
addNodeObject(animation, "FFT", Node_FFT, "Perform fourier transform on number array.")
.setIO(VALUE_TYPE.audioBit, VALUE_TYPE.float).setTags(["frequency analysis"])
.setVersion(1144);
ds_list_add(animation, "/Renders");
addNodeObject(animation, "Bar / Graph", Node_Plot_Linear, "Plot graph or bar chart from array of number.")
.setIO(VALUE_TYPE.surface, VALUE_TYPE.float).setBuild(Node_create_Plot_Linear).setTags(global.node_plot_linear_keys).setVersion(1144);
#endregion
#region misc
var node = ds_list_create();
addNodeCatagory("Misc", node);
ds_list_add(node, "Control");
addNodeObject(node, "Condition", Node_Condition, "Output value based on conditions.")
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Switch", Node_Switch, "Output value based on index.")
.setIO(VALUE_TYPE.any).setVersion(1090);
addNodeObject(node, "Animation Control", Node_Animation_Control, "Control animation state with triggers.")
.setIO(VALUE_TYPE.any).setVersion(1145);
ds_list_add(node, "Groups");
addNodeObject(node, "Group", Node_Group)
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Feedback", Node_Feedback, "Create a group that reuse output from last frame to the current one.")
.setIO(VALUE_TYPE.any).isDeprecated();
addNodeObject(node, "Loop", Node_Iterate, "Create group that reuse output as input repeatedly in one frame.")
.setIO(VALUE_TYPE.any).isDeprecated();
addNodeObject(node, "Loop Array", Node_Iterate_Each_Inline, "Create group that iterate to each member in an array.")
.setIO(VALUE_TYPE.any).setSpr(s_node_loop_array).setTags(["iterate each", "for each", "array loop"]);
addNodeObject(node, "Filter Array",Node_Iterate_Filter_Inline, "Filter array using condition.")
.setIO(VALUE_TYPE.any).setSpr(s_node_filter_array).setVersion(1140);
if(OS == os_windows) {
ds_list_add(node, "Lua");
addNodeObject(node, "Lua Global", Node_Lua_Global, "Execute lua script in global scope without returning any data.")
.setIO(VALUE_TYPE.any).setVersion(1090);
addNodeObject(node, "Lua Surface", Node_Lua_Surface, "Execute lua script on a surface.")
.setIO(VALUE_TYPE.any).setVersion(1090);
addNodeObject(node, "Lua Compute", Node_Lua_Compute, "Execute lua function and returns a data.")
.setIO(VALUE_TYPE.any).setVersion(1090);
ds_list_add(node, "Shader");
addNodeObject(node, "HLSL", Node_HLSL, "Execute HLSL shader on a surface.")
.setIO(VALUE_TYPE.any).setVersion(11520);
}
ds_list_add(node, "Organize");
addNodeObject(node, "Pin", Node_Pin, "Create a pin to organize your connection. Can be create by double clicking on a connection line.")
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Array Pin", Node_Array_Pin, "Create a pin that can receive multiple values and return an array.")
.setIO(VALUE_TYPE.any).setVersion(11770);
addNodeObject(node, "Frame", Node_Frame, "Create frame surrounding nodes.")
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Tunnel In", Node_Tunnel_In, "Create tunnel for sending value based on key matching.")
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Tunnel Out", Node_Tunnel_Out, "Receive value from tunnel in of the same key.")
.setIO(VALUE_TYPE.any);
addNodeObject(node, "Display Text", Node_Display_Text, "Display text on the graph.")
.setIO(VALUE_TYPE.text);
addNodeObject(node, "Display Image", Node_Display_Image, "Display image on the graph.")
.setIO(VALUE_TYPE.surface).setBuild(Node_create_Display_Image).setSpr(s_node_image);
ds_list_add(node, "Cache");
addNodeObject(node, "Cache", Node_Cache, "Store current animation. Cache persisted between save.")
.setIO(VALUE_TYPE.any).setVersion(1134);
addNodeObject(node, "Cache Array", Node_Cache_Array, "Store current animation as array. Cache persisted between save.")
.setIO(VALUE_TYPE.any).setVersion(1130);
ds_list_add(node, "Debug");
addNodeObject(node, "Print", Node_Print, "Display text to notification.")
.setIO(VALUE_TYPE.text).setTags(["debug log"]).setVersion(1145);
addNodeObject(node, "Widget Test", Node_Widget_Test)
.setSpr(s_node_print);
addNodeObject(node, "Graph Preview", Node_Graph_Preview)
.setIO(VALUE_TYPE.surface).setSpr(s_node_image);
addNodeObject(node, "Slideshow", Node_Slideshow)
.setIO(VALUE_TYPE.any).setSpr(s_node_image);
//addNodeObject(node, "Module Test", s_node_print, Node_Module_Test);
ds_list_add(node, "Project");
addNodeObject(node, "Project Data", Node_Project_Data)
.setIO(VALUE_TYPE.text).setVersion(11650);
ds_list_add(node, "System");
addNodeObject(node, "Argument", Node_Argument)
.setIO(VALUE_TYPE.any).setVersion(11660);
addNodeObject(node, "Terminal trigger", Node_Terminal_Trigger)
.setIO(VALUE_TYPE.any).setVersion(11660);
addNodeObject(node, "Execute Shell", Node_Shell, "Execute shell script.")
.setIO(VALUE_TYPE.any).setTags(["terminal", "execute", "run", "console"]).setVersion(11530);
addNodeObject(node, "Monitor Capture", Node_Monitor_Capture)
.setIO(VALUE_TYPE.any).notTest();
addNodeObject(node, "GUI In", Node_Application_In)
.setIO(VALUE_TYPE.any).setSpr(s_node_gui_in).notTest();
addNodeObject(node, "GUI Out", Node_Application_Out)
.setIO(VALUE_TYPE.any).setSpr(s_node_gui_out).notTest();
addNodeObject(node, "Assert", Node_Assert)
.setIO(VALUE_TYPE.any).setSpr(s_node_shell);
// addNodeObject(node, "DLL", s_node_gui_out, Node_DLL).setVersion(11750);
#endregion
globalvar NODE_ACTION_LIST;
NODE_ACTION_LIST = ds_list_create();
addNodeCatagory("Action", NODE_ACTION_LIST);
__initNodeActions();
var customs = ds_list_create();
addNodeCatagory("Custom", customs);
__initNodeCustom(customs);
if(IS_PATREON) addNodeCatagory("Extra", SUPPORTER_NODES);
//var vct = ds_list_create();
//addNodeCatagory("VCT", vct);
// addNodeObject(vct, "Biterator", s_node_print, Node_Biterator);
//////////////////////////////////////////////////////////// PIXEL BUILDER ////////////////////////////////////////////////////////////
#region pb_group
var pb_group = ds_list_create();
addNodePBCatagory("Group", pb_group); //#PB Group
ds_list_add(pb_group, "Groups");
addNodeObject(pb_group, "Input", Node_Group_Input)
.setIO(VALUE_TYPE.any).hideRecent();
addNodeObject(pb_group, "Output", Node_Group_Output)
.setIO(VALUE_TYPE.any).hideRecent();
#endregion
#region pb_draw
var pb_draw = ds_list_create();
addNodePBCatagory("Draw", pb_draw); //#PB Draw
ds_list_add(pb_draw, "Fill");
addNodeObject(pb_draw, "Fill", Node_PB_Draw_Fill)
.setIO(VALUE_TYPE.pbBox).hideRecent();
ds_list_add(pb_draw, "Shape");
addNodeObject(pb_draw, "Rectangle", Node_PB_Draw_Rectangle)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Round Rectangle", Node_PB_Draw_Round_Rectangle)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Trapezoid", Node_PB_Draw_Trapezoid)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Diamond", Node_PB_Draw_Diamond)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Ellipse", Node_PB_Draw_Ellipse)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Semi-Ellipse", Node_PB_Draw_Semi_Ellipse)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Line", Node_PB_Draw_Line)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Angle", Node_PB_Draw_Angle)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_draw, "Blob", Node_PB_Draw_Blob)
.setIO(VALUE_TYPE.pbBox).hideRecent();
#endregion
#region pb_box
var pb_box = ds_list_create();
addNodePBCatagory("Box", pb_box); //#PB Box
ds_list_add(pb_box, "Layer");
addNodeObject(pb_box, "Layer", Node_PB_Layer)
.setIO(VALUE_TYPE.pbBox).hideRecent();
ds_list_add(pb_box, "Box");
addNodeObject(pb_box, "Transform", Node_PB_Box_Transform)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Mirror", Node_PB_Box_Mirror)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Inset", Node_PB_Box_Inset)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Split", Node_PB_Box_Split)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Divide", Node_PB_Box_Divide)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Divide Grid", Node_PB_Box_Divide_Grid)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_box, "Contract", Node_PB_Box_Contract)
.setIO(VALUE_TYPE.pbBox).hideRecent();
#endregion
#region pb_fx
var pb_fx = ds_list_create();
addNodePBCatagory("Effects", pb_fx); //#PB Effects
ds_list_add(pb_fx, "Effect");
addNodeObject(pb_fx, "Outline", Node_PB_Fx_Outline)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Stack", Node_PB_Fx_Stack)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Radial", Node_PB_Fx_Radial)
.setIO(VALUE_TYPE.pbBox).hideRecent();
ds_list_add(pb_fx, "Lighting");
addNodeObject(pb_fx, "Highlight", Node_PB_Fx_Highlight)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Shading", Node_PB_Fx_Shading)
.setIO(VALUE_TYPE.pbBox).hideRecent();
ds_list_add(pb_fx, "Texture");
addNodeObject(pb_fx, "Hashing", Node_PB_Fx_Hash)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Strip", Node_PB_Fx_Strip)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Brick", Node_PB_Fx_Brick)
.setIO(VALUE_TYPE.pbBox).hideRecent();
ds_list_add(pb_fx, "Blend");
addNodeObject(pb_fx, "Add", Node_PB_Fx_Add)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Subtract", Node_PB_Fx_Subtract)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_fx, "Intersect", Node_PB_Fx_Intersect)
.setIO(VALUE_TYPE.pbBox).hideRecent();
#endregion
#region pb_arr
var pb_arr = ds_list_create();
addNodePBCatagory("Array", pb_arr); //#PB Array
addNodeObject(pb_arr, "Array", Node_Array)
.setIO(VALUE_TYPE.pbBox).hideRecent();
addNodeObject(pb_arr, "Array Get", Node_Array_Get)
.setIO(VALUE_TYPE.pbBox).setTags(["get array"]).hideRecent();
addNodeObject(pb_arr, "Array Set", Node_Array_Set)
.setIO(VALUE_TYPE.pbBox).setTags(["set array"]).hideRecent().setVersion(1120);
addNodeObject(pb_arr, "Array Insert", Node_Array_Insert)
.setIO(VALUE_TYPE.pbBox).setTags(["insert array"]).hideRecent().setVersion(1120);
addNodeObject(pb_arr, "Array Remove", Node_Array_Remove)
.setIO(VALUE_TYPE.pbBox).setTags(["remove array", "delete array", "array delete"]).hideRecent().setVersion(1120);
#endregion
/////////////////////////////////////////////////////////////// PCX NODE ///////////////////////////////////////////////////////////////
#region pcx_var
var pcx_var = ds_list_create();
addNodePCXCatagory("Variable", pcx_var);
addNodeObject(pcx_var, "Variable", Node_PCX_var)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
addNodeObject(pcx_var, "Fn Variable", Node_PCX_fn_var)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
#endregion
#region pcx_fn
var pcx_fn = ds_list_create();
addNodePCXCatagory("Functions", pcx_fn);
addNodeObject(pcx_fn, "Equation", Node_PCX_Equation)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
ds_list_add(pcx_fn, "Numbers");
addNodeObject(pcx_fn, "Math", Node_PCX_fn_Math)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
addNodeObject(pcx_fn, "Random", Node_PCX_fn_Random)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
ds_list_add(pcx_fn, "Surface");
addNodeObject(pcx_fn, "Surface Width", Node_PCX_fn_Surface_Width)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
addNodeObject(pcx_fn, "Surface Height", Node_PCX_fn_Surface_Height)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
ds_list_add(pcx_fn, "Array");
addNodeObject(pcx_fn, "Array Get", Node_PCX_Array_Get)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
addNodeObject(pcx_fn, "Array Set", Node_PCX_Array_Set)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
#endregion
#region pcx_flow
var pcx_flow = ds_list_create();
addNodePCXCatagory("Flow Control", pcx_flow);
addNodeObject(pcx_flow, "Condition", Node_PCX_Condition)
.setIO(VALUE_TYPE.pbBox).setSpr(s_node_array).hideRecent();
#endregion
//////////////////////////////////////////////////////////////// HIDDEN ////////////////////////////////////////////////////////////////
#region hid
var hid = ds_list_create();
addNodeCatagory("Hidden", hid, ["Hidden"]);
addNodeObject(hid, "Input", Node_Iterator_Each_Input)
.setSpr(s_node_loop_input).hideRecent();
addNodeObject(hid, "Output", Node_Iterator_Each_Output)
.setSpr(s_node_loop_output).hideRecent();
addNodeObject(hid, "Input", Node_Iterator_Filter_Input)
.setSpr(s_node_loop_input).hideRecent();
addNodeObject(hid, "Output", Node_Iterator_Filter_Output)
.setSpr(s_node_loop_output).hideRecent();
addNodeObject(hid, "Grid Noise", Node_Grid_Noise)
.hideRecent();
addNodeObject(hid, "Triangular Noise", Node_Noise_Tri)
.setSpr(s_node_grid_tri_noise).hideRecent().setVersion(1090);
addNodeObject(hid, "Hexagonal Noise", Node_Noise_Hex)
.setSpr(s_node_grid_hex_noise).hideRecent().setVersion(1090);
addNodeObject(hid, "Sort Input", Node_Iterator_Sort_Input)
.setSpr(s_node_grid_hex_noise).hideRecent();
addNodeObject(hid, "Sort Output", Node_Iterator_Sort_Output)
.setSpr(s_node_grid_hex_noise).hideRecent();
addNodeObject(hid, "Onion Skin", Node_Onion_Skin)
.setSpr(s_node_cache).setVersion(1147).hideRecent();
addNodeObject(hid, "RigidSim", Node_Rigid_Group, "Create group for rigidbody simulation.")
.setSpr(s_node_rigid).setVersion(1110).hideRecent();
addNodeObject(hid, "SmokeSim", Node_Smoke_Group, "Create group for fluid simulation.")
.setSpr(s_node_smoke_group).setVersion(1120).hideRecent();
addNodeObject(hid, "StrandSim", Node_Strand_Group, "Create group for hair simulation.")
.setSpr(s_node_strand).setVersion(1140).hideRecent();
addNodeObject(hid, "Feedback", Node_Feedback_Inline)
.setSpr(s_node_feedback).hideRecent();
addNodeObject(hid, "Loop", Node_Iterate_Inline)
.setSpr(s_node_iterate).hideRecent();
addNodeObject(hid, "VFX", Node_VFX_Group)
.setSpr(s_node_vfx).hideRecent();
addNodeObject(hid, "Loop Array", Node_Iterate_Each)
.setSpr(s_node_loop_array).hideRecent();
addNodeObject(hid, "Loop Input", Node_Iterator_Each_Inline_Input)
.setSpr(s_node_loop_array).hideRecent();
addNodeObject(hid, "Loop Output", Node_Iterator_Each_Inline_Output)
.setSpr(s_node_loop_array).hideRecent();
addNodeObject(hid, "Filter Array", Node_Iterate_Filter, "Filter array using condition.")
.setSpr(s_node_filter_array).hideRecent();
addNodeObject(hid, "Filter Input", Node_Iterator_Filter_Inline_Input)
.setSpr(s_node_filter_array).hideRecent();
addNodeObject(hid, "Filter Output", Node_Iterator_Filter_Inline_Output)
.setSpr(s_node_filter_array).hideRecent();
addNodeObject(hid, "Sort Array", Node_Iterate_Sort, "Sort array using node graph.")
.setSpr(s_node_sort_array).hideRecent();
addNodeObject(hid, "Sort Input", Node_Iterator_Sort_Inline_Input)
.setSpr(s_node_sort_array).hideRecent();
addNodeObject(hid, "Sort Output", Node_Iterator_Sort_Inline_Output)
.setSpr(s_node_sort_array).hideRecent();
ds_list_add(hid, "DynaSurf");
addNodeObject(hid, "Input", Node_DynaSurf_In)
.setSpr(s_node_pixel_builder).hideRecent();
addNodeObject(hid, "Output", Node_DynaSurf_Out)
.setSpr(s_node_pixel_builder).hideRecent();
addNodeObject(hid, "getWidth", Node_DynaSurf_Out_Width)
.setSpr(s_node_pixel_builder).hideRecent();
addNodeObject(hid, "getHeight", Node_DynaSurf_Out_Height)
.setSpr(s_node_pixel_builder).hideRecent();
#endregion
}
Reference in a new issue View git blame Copy permalink