diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index 4fa22b7c1..4022fc011 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -156,7 +156,6 @@
 #include "editor/plugins/tile_set_editor_plugin.h"
 #include "editor/plugins/version_control_editor_plugin.h"
 #include "editor/plugins/viewport_preview_editor_plugin.h"
-#include "editor/plugins/visual_shader_editor_plugin.h"
 #include "editor/progress_dialog.h"
 #include "editor/project_export.h"
 #include "editor/project_settings_editor.h"
@@ -5902,10 +5901,6 @@ EditorNode::EditorNode() {
 		Ref<EditorInspectorRootMotionPlugin> rmp;
 		rmp.instance();
 		EditorInspector::add_inspector_plugin(rmp);
-
-		Ref<EditorInspectorShaderModePlugin> smp;
-		smp.instance();
-		EditorInspector::add_inspector_plugin(smp);
 	}
 
 	editor_selection = memnew(EditorSelection);
@@ -6890,7 +6885,6 @@ EditorNode::EditorNode() {
 
 	add_editor_plugin(VersionControlEditorPlugin::get_singleton());
 	add_editor_plugin(memnew(ShaderEditorPlugin(this)));
-	add_editor_plugin(memnew(VisualShaderEditorPlugin(this)));
 
 	add_editor_plugin(memnew(CameraEditorPlugin(this)));
 	add_editor_plugin(memnew(ThemeEditorPlugin(this)));
@@ -6964,10 +6958,6 @@ EditorNode::EditorNode() {
 		Ref<ParticlesMaterialConversionPlugin> particles_mat_convert;
 		particles_mat_convert.instance();
 		resource_conversion_plugins.push_back(particles_mat_convert);
-
-		Ref<VisualShaderConversionPlugin> vshader_convert;
-		vshader_convert.instance();
-		resource_conversion_plugins.push_back(vshader_convert);
 	}
 	update_spinner_step_msec = OS::get_singleton()->get_ticks_msec();
 	update_spinner_step_frame = Engine::get_singleton()->get_frames_drawn();
diff --git a/editor/plugins/visual_shader_editor_plugin.cpp b/editor/plugins/visual_shader_editor_plugin.cpp
deleted file mode 100644
index a0ed93588..000000000
--- a/editor/plugins/visual_shader_editor_plugin.cpp
+++ /dev/null
@@ -1,3437 +0,0 @@
-/*************************************************************************/
-/*  visual_shader_editor_plugin.cpp                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "visual_shader_editor_plugin.h"
-
-#include "core/io/resource_loader.h"
-#include "core/math/math_defs.h"
-#include "core/os/input.h"
-#include "core/os/keyboard.h"
-#include "core/project_settings.h"
-#include "editor/editor_log.h"
-#include "editor/editor_properties.h"
-#include "editor/editor_scale.h"
-#include "scene/animation/animation_player.h"
-#include "scene/gui/menu_button.h"
-#include "scene/gui/panel.h"
-#include "scene/main/viewport.h"
-#include "scene/resources/visual_shader_nodes.h"
-#include "servers/visual/shader_types.h"
-
-Control *VisualShaderNodePlugin::create_editor(const Ref<Resource> &p_parent_resource, const Ref<VisualShaderNode> &p_node) {
-	if (get_script_instance()) {
-		return get_script_instance()->call("create_editor", p_parent_resource, p_node);
-	}
-	return nullptr;
-}
-
-void VisualShaderNodePlugin::_bind_methods() {
-	BIND_VMETHOD(MethodInfo(Variant::OBJECT, "create_editor", PropertyInfo(Variant::OBJECT, "parent_resource", PROPERTY_HINT_RESOURCE_TYPE, "Resource"), PropertyInfo(Variant::OBJECT, "for_node", PROPERTY_HINT_RESOURCE_TYPE, "VisualShaderNode")));
-}
-
-///////////////////
-
-void VisualShaderEditor::edit(VisualShader *p_visual_shader) {
-	bool changed = false;
-	if (p_visual_shader) {
-		if (visual_shader.is_null()) {
-			changed = true;
-		} else {
-			if (visual_shader.ptr() != p_visual_shader) {
-				changed = true;
-			}
-		}
-		visual_shader = Ref<VisualShader>(p_visual_shader);
-		if (!visual_shader->is_connected("changed", this, "_update_preview")) {
-			visual_shader->connect("changed", this, "_update_preview");
-		}
-		visual_shader->set_graph_offset(graph->get_scroll_ofs() / EDSCALE);
-	} else {
-		if (visual_shader.is_valid()) {
-			if (visual_shader->is_connected("changed", this, "")) {
-				visual_shader->disconnect("changed", this, "_update_preview");
-			}
-		}
-		visual_shader.unref();
-	}
-
-	if (visual_shader.is_null()) {
-		hide();
-	} else {
-		if (changed) { // to avoid tree collapse
-			_clear_buffer();
-			_update_options_menu();
-			_update_preview();
-		}
-		_update_graph();
-	}
-}
-
-void VisualShaderEditor::add_plugin(const Ref<VisualShaderNodePlugin> &p_plugin) {
-	if (plugins.find(p_plugin) != -1) {
-		return;
-	}
-	plugins.push_back(p_plugin);
-}
-
-void VisualShaderEditor::remove_plugin(const Ref<VisualShaderNodePlugin> &p_plugin) {
-	plugins.erase(p_plugin);
-}
-
-void VisualShaderEditor::clear_custom_types() {
-	for (int i = 0; i < add_options.size(); i++) {
-		if (add_options[i].is_custom) {
-			add_options.remove(i);
-			i--;
-		}
-	}
-}
-
-void VisualShaderEditor::add_custom_type(const String &p_name, const Ref<Script> &p_script, const String &p_description, int p_return_icon_type, const String &p_category, const String &p_subcategory) {
-	ERR_FAIL_COND(!p_name.is_valid_identifier());
-	ERR_FAIL_COND(!p_script.is_valid());
-
-	for (int i = 0; i < add_options.size(); i++) {
-		if (add_options[i].is_custom) {
-			if (add_options[i].script == p_script) {
-				return;
-			}
-		}
-	}
-
-	AddOption ao;
-	ao.name = p_name;
-	ao.script = p_script;
-	ao.return_type = p_return_icon_type;
-	ao.description = p_description;
-	ao.category = p_category;
-	ao.sub_category = p_subcategory;
-	ao.is_custom = true;
-
-	bool begin = false;
-
-	for (int i = 0; i < add_options.size(); i++) {
-		if (add_options[i].is_custom) {
-			if (add_options[i].category == p_category) {
-				if (!begin) {
-					begin = true;
-				}
-			} else {
-				if (begin) {
-					add_options.insert(i, ao);
-					return;
-				}
-			}
-		}
-	}
-	add_options.push_back(ao);
-}
-
-bool VisualShaderEditor::_is_available(int p_mode) {
-	int current_mode = edit_type->get_selected();
-
-	if (p_mode != -1) {
-		switch (current_mode) {
-			case VisualShader::TYPE_VERTEX:
-				current_mode = 1;
-				break;
-			case VisualShader::TYPE_FRAGMENT:
-				current_mode = 2;
-				break;
-			case VisualShader::TYPE_LIGHT:
-				current_mode = 4;
-				break;
-			default:
-				break;
-		}
-
-		int temp_mode = 0;
-
-		if (p_mode & VisualShader::TYPE_FRAGMENT) {
-			temp_mode |= 2;
-		}
-
-		if (p_mode & VisualShader::TYPE_LIGHT) {
-			temp_mode |= 4;
-		}
-
-		if (temp_mode == 0) {
-			temp_mode |= 1;
-		}
-
-		p_mode = temp_mode;
-	}
-
-	return (p_mode == -1 || (p_mode & current_mode) != 0);
-}
-
-void VisualShaderEditor::update_custom_nodes() {
-	if (members_dialog->is_visible()) {
-		return;
-	}
-	clear_custom_types();
-	List<StringName> class_list;
-	ScriptServer::get_global_class_list(&class_list);
-	Dictionary added;
-	for (int i = 0; i < class_list.size(); i++) {
-		if (ScriptServer::get_global_class_native_base(class_list[i]) == "VisualShaderNodeCustom") {
-			String script_path = ScriptServer::get_global_class_path(class_list[i]);
-			Ref<Resource> res = ResourceLoader::load(script_path);
-			ERR_FAIL_COND(res.is_null());
-			ERR_FAIL_COND(!res->is_class("Script"));
-			Ref<Script> script = Ref<Script>(res);
-
-			Ref<VisualShaderNodeCustom> ref;
-			ref.instance();
-			ref->set_script(script.get_ref_ptr());
-
-			String name;
-			if (ref->has_method("_get_name")) {
-				name = (String)ref->call("_get_name");
-			} else {
-				name = "Unnamed";
-			}
-
-			String description = "";
-			if (ref->has_method("_get_description")) {
-				description = (String)ref->call("_get_description");
-			}
-
-			int return_icon_type = -1;
-			if (ref->has_method("_get_return_icon_type")) {
-				return_icon_type = (int)ref->call("_get_return_icon_type");
-			}
-
-			String category = "";
-			if (ref->has_method("_get_category")) {
-				category = (String)ref->call("_get_category");
-			}
-			if (category == "") {
-				category = "Custom";
-			}
-
-			String subcategory = "";
-			if (ref->has_method("_get_subcategory")) {
-				subcategory = (String)ref->call("_get_subcategory");
-			}
-
-			Dictionary dict;
-			dict["name"] = name;
-			dict["script"] = script;
-			dict["description"] = description;
-			dict["return_icon_type"] = return_icon_type;
-			dict["category"] = category;
-			dict["subcategory"] = subcategory;
-
-			String key;
-			key = category;
-			key += "/";
-			if (subcategory != "") {
-				key += subcategory;
-				key += "/";
-			}
-			key += name;
-
-			added[key] = dict;
-		}
-	}
-
-	Array keys = added.keys();
-	keys.sort();
-
-	for (int i = 0; i < keys.size(); i++) {
-		const Variant &key = keys.get(i);
-
-		const Dictionary &value = (Dictionary)added[key];
-
-		add_custom_type(value["name"], value["script"], value["description"], value["return_icon_type"], value["category"], value["subcategory"]);
-	}
-
-	_update_options_menu();
-}
-
-String VisualShaderEditor::_get_description(int p_idx) {
-	if (add_options[p_idx].highend) {
-		return TTR("(GLES3 only)") + " " + add_options[p_idx].description; // TODO: change it to (Vulkan Only) when its ready
-	} else {
-		return add_options[p_idx].description;
-	}
-}
-
-void VisualShaderEditor::_update_options_menu() {
-	node_desc->set_text("");
-	members_dialog->get_ok()->set_disabled(true);
-
-	String prev_category;
-	String prev_sub_category;
-
-	members->clear();
-	TreeItem *root = members->create_item();
-	TreeItem *category = nullptr;
-	TreeItem *sub_category = nullptr;
-
-	String filter = node_filter->get_text().strip_edges();
-	bool use_filter = !filter.empty();
-
-	Vector<String> categories;
-	Vector<String> sub_categories;
-
-	int item_count = 0;
-	int item_count2 = 0;
-	bool is_first_item = true;
-
-	Color unsupported_color = get_color("error_color", "Editor");
-	Color supported_color = get_color("warning_color", "Editor");
-
-	static bool low_driver = ProjectSettings::get_singleton()->get("rendering/quality/driver/driver_name") == "GLES2";
-
-	int current_func = -1;
-
-	if (!visual_shader.is_null()) {
-		current_func = visual_shader->get_mode();
-	}
-
-	for (int i = 0; i < add_options.size() + 1; i++) {
-		if (i == add_options.size()) {
-			if (sub_category != nullptr && item_count2 == 0) {
-				memdelete(sub_category);
-				--item_count;
-			}
-			if (category != nullptr && item_count == 0) {
-				memdelete(category);
-			}
-			break;
-		}
-
-		if (!use_filter || add_options[i].name.findn(filter) != -1) {
-			if ((add_options[i].func != current_func && add_options[i].func != -1) || !_is_available(add_options[i].mode)) {
-				continue;
-			}
-
-			if (prev_category != add_options[i].category) {
-				if (category != nullptr && item_count == 0) {
-					memdelete(category);
-				}
-
-				item_count = 0;
-				prev_sub_category = "";
-				category = members->create_item(root);
-				category->set_text(0, add_options[i].category);
-				category->set_selectable(0, false);
-				if (!use_filter) {
-					category->set_collapsed(true);
-				}
-			}
-
-			if (add_options[i].sub_category != "") {
-				if (prev_sub_category != add_options[i].sub_category) {
-					if (category != nullptr) {
-						if (sub_category != nullptr && item_count2 == 0) {
-							memdelete(sub_category);
-							--item_count;
-						}
-						++item_count;
-						item_count2 = 0;
-						sub_category = members->create_item(category);
-						sub_category->set_text(0, add_options[i].sub_category);
-						sub_category->set_selectable(0, false);
-						if (!use_filter) {
-							sub_category->set_collapsed(true);
-						}
-					}
-				}
-			} else {
-				sub_category = nullptr;
-			}
-
-			TreeItem *p_category = nullptr;
-
-			if (sub_category != nullptr) {
-				p_category = sub_category;
-				++item_count2;
-			} else if (category != nullptr) {
-				p_category = category;
-				++item_count;
-			}
-
-			if (p_category != nullptr) {
-				TreeItem *item = members->create_item(p_category);
-				if (add_options[i].highend && low_driver) {
-					item->set_custom_color(0, unsupported_color);
-				} else if (add_options[i].highend) {
-					item->set_custom_color(0, supported_color);
-				}
-				item->set_text(0, add_options[i].name);
-				if (is_first_item && use_filter) {
-					item->select(0);
-					node_desc->set_text(_get_description(i));
-					is_first_item = false;
-				}
-				switch (add_options[i].return_type) {
-					case VisualShaderNode::PORT_TYPE_SCALAR:
-						item->set_icon(0, EditorNode::get_singleton()->get_gui_base()->get_icon("float", "EditorIcons"));
-						break;
-					case VisualShaderNode::PORT_TYPE_VECTOR:
-						item->set_icon(0, EditorNode::get_singleton()->get_gui_base()->get_icon("Vector3", "EditorIcons"));
-						break;
-					case VisualShaderNode::PORT_TYPE_BOOLEAN:
-						item->set_icon(0, EditorNode::get_singleton()->get_gui_base()->get_icon("bool", "EditorIcons"));
-						break;
-					case VisualShaderNode::PORT_TYPE_TRANSFORM:
-						item->set_icon(0, EditorNode::get_singleton()->get_gui_base()->get_icon("Transform", "EditorIcons"));
-						break;
-					case VisualShaderNode::PORT_TYPE_SAMPLER:
-						item->set_icon(0, EditorNode::get_singleton()->get_gui_base()->get_icon("ImageTexture", "EditorIcons"));
-						break;
-					default:
-						break;
-				}
-				item->set_meta("id", i);
-			}
-
-			prev_sub_category = add_options[i].sub_category;
-			prev_category = add_options[i].category;
-		}
-	}
-}
-
-Size2 VisualShaderEditor::get_minimum_size() const {
-	return Size2(10, 200);
-}
-
-void VisualShaderEditor::_draw_color_over_button(Object *obj, Color p_color) {
-	Button *button = Object::cast_to<Button>(obj);
-	if (!button) {
-		return;
-	}
-
-	Ref<StyleBox> normal = get_stylebox("normal", "Button");
-	button->draw_rect(Rect2(normal->get_offset(), button->get_size() - normal->get_minimum_size()), p_color);
-}
-
-static Ref<StyleBoxEmpty> make_empty_stylebox(float p_margin_left = -1, float p_margin_top = -1, float p_margin_right = -1, float p_margin_bottom = -1) {
-	Ref<StyleBoxEmpty> style(memnew(StyleBoxEmpty));
-	style->set_default_margin(MARGIN_LEFT, p_margin_left * EDSCALE);
-	style->set_default_margin(MARGIN_RIGHT, p_margin_right * EDSCALE);
-	style->set_default_margin(MARGIN_BOTTOM, p_margin_bottom * EDSCALE);
-	style->set_default_margin(MARGIN_TOP, p_margin_top * EDSCALE);
-	return style;
-}
-
-void VisualShaderEditor::_update_created_node(GraphNode *node) {
-	if (EditorSettings::get_singleton()->get("interface/theme/use_graph_node_headers")) {
-		Ref<StyleBoxFlat> sb = node->get_stylebox("frame", "GraphNode");
-		Color c = sb->get_border_color();
-		Color mono_color = ((c.r + c.g + c.b) / 3) < 0.7 ? Color(1.0, 1.0, 1.0) : Color(0.0, 0.0, 0.0);
-		mono_color.a = 0.85;
-		c = mono_color;
-
-		node->add_color_override("title_color", c);
-		c.a = 0.7;
-		node->add_color_override("close_color", c);
-		node->add_color_override("resizer_color", c);
-	}
-}
-
-void VisualShaderEditor::_update_graph() {
-	if (updating) {
-		return;
-	}
-
-	if (visual_shader.is_null()) {
-		return;
-	}
-
-	graph->set_scroll_ofs(visual_shader->get_graph_offset() * EDSCALE);
-
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	graph->clear_connections();
-	//erase all nodes
-	for (int i = 0; i < graph->get_child_count(); i++) {
-		if (Object::cast_to<GraphNode>(graph->get_child(i))) {
-			Node *node = graph->get_child(i);
-			graph->remove_child(node);
-			memdelete(node);
-			i--;
-		}
-	}
-
-	static const Color type_color[5] = {
-		Color(0.38, 0.85, 0.96), // scalar
-		Color(0.84, 0.49, 0.93), // vector
-		Color(0.55, 0.65, 0.94), // boolean
-		Color(0.96, 0.66, 0.43), // transform
-		Color(1.0, 1.0, 0.0) // sampler
-	};
-
-	List<VisualShader::Connection> connections;
-	visual_shader->get_node_connections(type, &connections);
-
-	Ref<StyleBoxEmpty> label_style = make_empty_stylebox(2, 1, 2, 1);
-
-	Vector<int> nodes = visual_shader->get_node_list(type);
-
-	VisualShaderNodeUniformRef::clear_uniforms();
-
-	// scan for all uniforms
-
-	for (int t = 0; t < VisualShader::TYPE_MAX; t++) {
-		Vector<int> tnodes = visual_shader->get_node_list((VisualShader::Type)t);
-		for (int i = 0; i < tnodes.size(); i++) {
-			Ref<VisualShaderNode> vsnode = visual_shader->get_node((VisualShader::Type)t, tnodes[i]);
-			Ref<VisualShaderNodeUniform> uniform = vsnode;
-
-			if (uniform.is_valid()) {
-				Ref<VisualShaderNodeScalarUniform> scalar_uniform = vsnode;
-				Ref<VisualShaderNodeVec3Uniform> vec3_uniform = vsnode;
-				Ref<VisualShaderNodeColorUniform> color_uniform = vsnode;
-				Ref<VisualShaderNodeBooleanUniform> bool_uniform = vsnode;
-				Ref<VisualShaderNodeTransformUniform> transform_uniform = vsnode;
-
-				VisualShaderNodeUniformRef::UniformType uniform_type;
-				if (scalar_uniform.is_valid()) {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_SCALAR;
-				} else if (bool_uniform.is_valid()) {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_BOOLEAN;
-				} else if (vec3_uniform.is_valid()) {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_VECTOR;
-				} else if (transform_uniform.is_valid()) {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_TRANSFORM;
-				} else if (color_uniform.is_valid()) {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_COLOR;
-				} else {
-					uniform_type = VisualShaderNodeUniformRef::UniformType::UNIFORM_TYPE_SAMPLER;
-				}
-				VisualShaderNodeUniformRef::add_uniform(uniform->get_uniform_name(), uniform_type);
-			}
-		}
-	}
-
-	Control *offset;
-
-	for (int n_i = 0; n_i < nodes.size(); n_i++) {
-		Vector2 position = visual_shader->get_node_position(type, nodes[n_i]);
-		Ref<VisualShaderNode> vsnode = visual_shader->get_node(type, nodes[n_i]);
-
-		Ref<VisualShaderNodeGroupBase> group_node = Object::cast_to<VisualShaderNodeGroupBase>(vsnode.ptr());
-		bool is_group = !group_node.is_null();
-		Size2 size = Size2(0, 0);
-
-		VisualShaderNodeCustom *custom = Object::cast_to<VisualShaderNodeCustom>(vsnode.ptr());
-		if (custom) {
-			custom->_set_initialized(true);
-		}
-
-		Ref<VisualShaderNodeExpression> expression_node = Object::cast_to<VisualShaderNodeExpression>(group_node.ptr());
-		bool is_expression = !expression_node.is_null();
-		String expression = "";
-
-		GraphNode *node = memnew(GraphNode);
-
-		if (is_group) {
-			size = group_node->get_size();
-
-			node->set_resizable(true);
-			node->connect("resize_request", this, "_node_resized", varray((int)type, nodes[n_i]));
-		}
-		if (is_expression) {
-			expression = expression_node->get_expression();
-		}
-
-		/*if (!vsnode->is_connected("changed", this, "_node_changed")) {
-			vsnode->connect("changed", this, "_node_changed", varray(vsnode->get_instance_id()), CONNECT_DEFERRED);
-		}*/
-
-		node->set_offset(position);
-
-		node->set_title(vsnode->get_caption());
-		node->set_name(itos(nodes[n_i]));
-
-		if (nodes[n_i] >= 2) {
-			node->set_show_close_button(true);
-			node->connect("close_request", this, "_delete_request", varray(nodes[n_i]), CONNECT_DEFERRED);
-		}
-
-		node->connect("dragged", this, "_node_dragged", varray(nodes[n_i]));
-
-		Control *custom_editor = nullptr;
-		int port_offset = 0;
-
-		if (is_group) {
-			port_offset += 2;
-		}
-
-		Ref<VisualShaderNodeUniform> uniform = vsnode;
-		HBoxContainer *uniform_hbox = nullptr;
-
-		if (uniform.is_valid()) {
-			graph->add_child(node);
-			_update_created_node(node);
-
-			LineEdit *uniform_name = memnew(LineEdit);
-			uniform_name->set_h_size_flags(SIZE_EXPAND_FILL);
-			uniform_name->set_text(uniform->get_uniform_name());
-			uniform_name->connect("text_entered", this, "_line_edit_changed", varray(uniform_name, nodes[n_i]));
-			uniform_name->connect("focus_exited", this, "_line_edit_focus_out", varray(uniform_name, nodes[n_i]));
-
-			if (vsnode->get_output_port_count() == 1 && vsnode->get_output_port_name(0) == "") {
-				uniform_hbox = memnew(HBoxContainer);
-				uniform_hbox->add_constant_override("separation", 7 * EDSCALE);
-				uniform_hbox->add_child(uniform_name);
-				node->add_child(uniform_hbox);
-			} else {
-				node->add_child(uniform_name);
-			}
-			port_offset++;
-		}
-
-		for (int i = 0; i < plugins.size(); i++) {
-			custom_editor = plugins.write[i]->create_editor(visual_shader, vsnode);
-			if (custom_editor) {
-				break;
-			}
-		}
-
-		if (custom_editor) {
-			if (uniform_hbox == nullptr && vsnode->get_output_port_count() > 0 && vsnode->get_output_port_name(0) == "" && (vsnode->get_input_port_count() == 0 || vsnode->get_input_port_name(0) == "")) {
-				//will be embedded in first port
-			} else {
-				port_offset++;
-				node->add_child(custom_editor);
-				custom_editor = nullptr;
-			}
-		}
-
-		if (is_group) {
-			offset = memnew(Control);
-			offset->set_custom_minimum_size(Size2(0, 6 * EDSCALE));
-			node->add_child(offset);
-
-			if (group_node->is_editable()) {
-				HBoxContainer *hb2 = memnew(HBoxContainer);
-
-				Button *add_input_btn = memnew(Button);
-				add_input_btn->set_text(TTR("Add Input"));
-				add_input_btn->connect("pressed", this, "_add_input_port", varray(nodes[n_i], group_node->get_free_input_port_id(), VisualShaderNode::PORT_TYPE_VECTOR, "input" + itos(group_node->get_free_input_port_id())), CONNECT_DEFERRED);
-				hb2->add_child(add_input_btn);
-
-				hb2->add_spacer();
-
-				Button *add_output_btn = memnew(Button);
-				add_output_btn->set_text(TTR("Add Output"));
-				add_output_btn->connect("pressed", this, "_add_output_port", varray(nodes[n_i], group_node->get_free_output_port_id(), VisualShaderNode::PORT_TYPE_VECTOR, "output" + itos(group_node->get_free_output_port_id())), CONNECT_DEFERRED);
-				hb2->add_child(add_output_btn);
-
-				node->add_child(hb2);
-			}
-		}
-
-		for (int i = 0; i < MAX(vsnode->get_input_port_count(), vsnode->get_output_port_count()); i++) {
-			if (vsnode->is_port_separator(i)) {
-				node->add_child(memnew(HSeparator));
-				port_offset++;
-			}
-
-			bool valid_left = i < vsnode->get_input_port_count();
-			VisualShaderNode::PortType port_left = VisualShaderNode::PORT_TYPE_SCALAR;
-			bool port_left_used = false;
-			String name_left;
-			if (valid_left) {
-				name_left = vsnode->get_input_port_name(i);
-				port_left = vsnode->get_input_port_type(i);
-				for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) {
-					if (E->get().to_node == nodes[n_i] && E->get().to_port == i) {
-						port_left_used = true;
-					}
-				}
-			}
-
-			bool valid_right = i < vsnode->get_output_port_count();
-			VisualShaderNode::PortType port_right = VisualShaderNode::PORT_TYPE_SCALAR;
-			String name_right;
-			if (valid_right) {
-				name_right = vsnode->get_output_port_name(i);
-				port_right = vsnode->get_output_port_type(i);
-			}
-
-			HBoxContainer *hb = nullptr;
-			bool is_uniform_hbox = false;
-			if (i == 0 && uniform_hbox != nullptr) {
-				hb = uniform_hbox;
-				is_uniform_hbox = true;
-			} else {
-				hb = memnew(HBoxContainer);
-				hb->add_constant_override("separation", 7 * EDSCALE);
-			}
-
-			Variant default_value;
-
-			if (valid_left && !port_left_used) {
-				default_value = vsnode->get_input_port_default_value(i);
-			}
-
-			if (default_value.get_type() != Variant::NIL) { // only a label
-				Button *button = memnew(Button);
-				hb->add_child(button);
-				button->connect("pressed", this, "_edit_port_default_input", varray(button, nodes[n_i], i));
-
-				switch (default_value.get_type()) {
-					case Variant::COLOR: {
-						button->set_custom_minimum_size(Size2(30, 0) * EDSCALE);
-						button->connect("draw", this, "_draw_color_over_button", varray(button, default_value));
-					} break;
-					case Variant::BOOL: {
-						button->set_text(((bool)default_value) ? "true" : "false");
-					} break;
-					case Variant::INT:
-					case Variant::REAL: {
-						button->set_text(String::num(default_value, 4));
-					} break;
-					case Variant::VECTOR3: {
-						Vector3 v = default_value;
-						button->set_text(String::num(v.x, 3) + "," + String::num(v.y, 3) + "," + String::num(v.z, 3));
-					} break;
-					default: {
-					}
-				}
-			}
-
-			if (i == 0 && custom_editor) {
-				hb->add_child(custom_editor);
-				custom_editor->set_h_size_flags(SIZE_EXPAND_FILL);
-			} else {
-				if (valid_left) {
-					if (is_group) {
-						OptionButton *type_box = memnew(OptionButton);
-						hb->add_child(type_box);
-						type_box->add_item(TTR("Scalar"));
-						type_box->add_item(TTR("Vector"));
-						type_box->add_item(TTR("Boolean"));
-						type_box->add_item(TTR("Transform"));
-						type_box->add_item(TTR("Sampler"));
-						type_box->select(group_node->get_input_port_type(i));
-						type_box->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
-						type_box->connect("item_selected", this, "_change_input_port_type", varray(nodes[n_i], i), CONNECT_DEFERRED);
-
-						LineEdit *name_box = memnew(LineEdit);
-						hb->add_child(name_box);
-						name_box->set_custom_minimum_size(Size2(65 * EDSCALE, 0));
-						name_box->set_h_size_flags(SIZE_EXPAND_FILL);
-						name_box->set_text(name_left);
-						name_box->connect("text_entered", this, "_change_input_port_name", varray(name_box, nodes[n_i], i));
-						name_box->connect("focus_exited", this, "_port_name_focus_out", varray(name_box, nodes[n_i], i, false));
-
-						Button *remove_btn = memnew(Button);
-						remove_btn->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("Remove", "EditorIcons"));
-						remove_btn->set_tooltip(TTR("Remove") + " " + name_left);
-						remove_btn->connect("pressed", this, "_remove_input_port", varray(nodes[n_i], i), CONNECT_DEFERRED);
-						hb->add_child(remove_btn);
-					} else {
-						Label *label = memnew(Label);
-						label->set_text(name_left);
-						label->add_style_override("normal", label_style); //more compact
-						hb->add_child(label);
-
-						if (vsnode->get_input_port_default_hint(i) != "" && !port_left_used) {
-							Label *hint_label = memnew(Label);
-							hint_label->set_text("[" + vsnode->get_input_port_default_hint(i) + "]");
-							hint_label->add_color_override("font_color", get_color("font_color_readonly", "TextEdit"));
-							hint_label->add_style_override("normal", label_style);
-							hb->add_child(hint_label);
-						}
-					}
-				}
-
-				if (!is_group && !is_uniform_hbox) {
-					hb->add_spacer();
-				}
-
-				if (valid_right) {
-					if (is_group) {
-						Button *remove_btn = memnew(Button);
-						remove_btn->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("Remove", "EditorIcons"));
-						remove_btn->set_tooltip(TTR("Remove") + " " + name_left);
-						remove_btn->connect("pressed", this, "_remove_output_port", varray(nodes[n_i], i), CONNECT_DEFERRED);
-						hb->add_child(remove_btn);
-
-						LineEdit *name_box = memnew(LineEdit);
-						hb->add_child(name_box);
-						name_box->set_custom_minimum_size(Size2(65 * EDSCALE, 0));
-						name_box->set_h_size_flags(SIZE_EXPAND_FILL);
-						name_box->set_text(name_right);
-						name_box->connect("text_entered", this, "_change_output_port_name", varray(name_box, nodes[n_i], i));
-						name_box->connect("focus_exited", this, "_port_name_focus_out", varray(name_box, nodes[n_i], i, true));
-
-						OptionButton *type_box = memnew(OptionButton);
-						hb->add_child(type_box);
-						type_box->add_item(TTR("Scalar"));
-						type_box->add_item(TTR("Vector"));
-						type_box->add_item(TTR("Boolean"));
-						type_box->add_item(TTR("Transform"));
-						type_box->select(group_node->get_output_port_type(i));
-						type_box->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
-						type_box->connect("item_selected", this, "_change_output_port_type", varray(nodes[n_i], i), CONNECT_DEFERRED);
-					} else {
-						if (name_right != "") {
-							Label *label = memnew(Label);
-							label->set_text(name_right);
-							label->add_style_override("normal", label_style); //more compact
-							hb->add_child(label);
-						}
-					}
-				}
-			}
-
-			if (valid_right && edit_type->get_selected() == VisualShader::TYPE_FRAGMENT && port_right != VisualShaderNode::PORT_TYPE_TRANSFORM && port_right != VisualShaderNode::PORT_TYPE_SAMPLER) {
-				TextureButton *preview = memnew(TextureButton);
-				preview->set_toggle_mode(true);
-				preview->set_normal_texture(get_icon("GuiVisibilityHidden", "EditorIcons"));
-				preview->set_pressed_texture(get_icon("GuiVisibilityVisible", "EditorIcons"));
-				preview->set_v_size_flags(SIZE_SHRINK_CENTER);
-
-				if (vsnode->get_output_port_for_preview() == i) {
-					preview->set_pressed(true);
-				}
-
-				preview->connect("pressed", this, "_preview_select_port", varray(nodes[n_i], i), CONNECT_DEFERRED);
-				hb->add_child(preview);
-			}
-
-			if (is_group) {
-				offset = memnew(Control);
-				offset->set_custom_minimum_size(Size2(0, 5 * EDSCALE));
-				node->add_child(offset);
-				port_offset++;
-			}
-
-			int idx = 0;
-			if (!is_uniform_hbox) {
-				node->add_child(hb);
-				idx = i + port_offset;
-			}
-			node->set_slot(idx, valid_left, port_left, type_color[port_left], valid_right, port_right, type_color[port_right]);
-		}
-
-		if (vsnode->get_output_port_for_preview() >= 0) {
-			int port_type = vsnode->get_output_port_type(vsnode->get_output_port_for_preview());
-
-			if (port_type != VisualShaderNode::PORT_TYPE_TRANSFORM && port_type != VisualShaderNode::PORT_TYPE_SAMPLER) {
-				offset = memnew(Control);
-				offset->set_custom_minimum_size(Size2(0, 5 * EDSCALE));
-				node->add_child(offset);
-
-				VisualShaderNodePortPreview *port_preview = memnew(VisualShaderNodePortPreview);
-				port_preview->setup(visual_shader, type, nodes[n_i], vsnode->get_output_port_for_preview());
-				port_preview->set_h_size_flags(SIZE_SHRINK_CENTER);
-				node->add_child(port_preview);
-			}
-		}
-
-		offset = memnew(Control);
-		offset->set_custom_minimum_size(Size2(0, 4 * EDSCALE));
-		node->add_child(offset);
-
-		String error = vsnode->get_warning(visual_shader->get_mode(), type);
-		if (error != String()) {
-			Label *error_label = memnew(Label);
-			error_label->add_color_override("font_color", get_color("error_color", "Editor"));
-			error_label->set_text(error);
-			node->add_child(error_label);
-		}
-
-		if (is_expression) {
-			TextEdit *expression_box = memnew(TextEdit);
-			expression_node->set_control(expression_box, 0);
-			node->add_child(expression_box);
-
-			Color background_color = EDITOR_GET("text_editor/highlighting/background_color");
-			Color text_color = EDITOR_GET("text_editor/highlighting/text_color");
-			Color keyword_color = EDITOR_GET("text_editor/highlighting/keyword_color");
-			Color control_flow_keyword_color = EDITOR_GET("text_editor/highlighting/control_flow_keyword_color");
-			Color comment_color = EDITOR_GET("text_editor/highlighting/comment_color");
-			Color symbol_color = EDITOR_GET("text_editor/highlighting/symbol_color");
-
-			expression_box->set_syntax_coloring(true);
-			expression_box->add_color_override("background_color", background_color);
-
-			for (List<String>::Element *E = keyword_list.front(); E; E = E->next()) {
-				if (ShaderLanguage::is_control_flow_keyword(E->get())) {
-					expression_box->add_keyword_color(E->get(), control_flow_keyword_color);
-				} else {
-					expression_box->add_keyword_color(E->get(), keyword_color);
-				}
-			}
-
-			expression_box->add_font_override("font", get_font("expression", "EditorFonts"));
-			expression_box->add_color_override("font_color", text_color);
-			expression_box->add_color_override("symbol_color", symbol_color);
-			expression_box->add_color_region("/*", "*/", comment_color, false);
-			expression_box->add_color_region("//", "", comment_color, false);
-
-			expression_box->set_text(expression);
-			expression_box->set_context_menu_enabled(false);
-			expression_box->set_show_line_numbers(true);
-
-			expression_box->connect("focus_exited", this, "_expression_focus_out", varray(expression_box, nodes[n_i]));
-		}
-
-		if (!uniform.is_valid()) {
-			graph->add_child(node);
-			_update_created_node(node);
-			if (is_group) {
-				call_deferred("_set_node_size", (int)type, nodes[n_i], size);
-			}
-		}
-	}
-
-	for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) {
-		int from = E->get().from_node;
-		int from_idx = E->get().from_port;
-		int to = E->get().to_node;
-		int to_idx = E->get().to_port;
-
-		graph->connect_node(itos(from), from_idx, itos(to), to_idx);
-	}
-
-	float graph_minimap_opacity = EditorSettings::get_singleton()->get("editors/visual_editors/minimap_opacity");
-	graph->set_minimap_opacity(graph_minimap_opacity);
-}
-
-void VisualShaderEditor::_add_input_port(int p_node, int p_port, int p_port_type, const String &p_name) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeExpression> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Add input port"));
-	undo_redo->add_do_method(node.ptr(), "add_input_port", p_port, p_port_type, p_name);
-	undo_redo->add_undo_method(node.ptr(), "remove_input_port", p_port);
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_add_output_port(int p_node, int p_port, int p_port_type, const String &p_name) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Add output port"));
-	undo_redo->add_do_method(node.ptr(), "add_output_port", p_port, p_port_type, p_name);
-	undo_redo->add_undo_method(node.ptr(), "remove_output_port", p_port);
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_change_input_port_type(int p_type, int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Change input port type"));
-	undo_redo->add_do_method(node.ptr(), "set_input_port_type", p_port, p_type);
-	undo_redo->add_undo_method(node.ptr(), "set_input_port_type", p_port, node->get_input_port_type(p_port));
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_change_output_port_type(int p_type, int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Change output port type"));
-	undo_redo->add_do_method(node.ptr(), "set_output_port_type", p_port, p_type);
-	undo_redo->add_undo_method(node.ptr(), "set_output_port_type", p_port, node->get_output_port_type(p_port));
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_change_input_port_name(const String &p_text, Object *line_edit, int p_node_id, int p_port_id) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node_id);
-	ERR_FAIL_COND(!node.is_valid());
-
-	undo_redo->create_action(TTR("Change input port name"));
-	undo_redo->add_do_method(node.ptr(), "set_input_port_name", p_port_id, p_text);
-	undo_redo->add_undo_method(node.ptr(), "set_input_port_name", p_port_id, node->get_input_port_name(p_port_id));
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_change_output_port_name(const String &p_text, Object *line_edit, int p_node_id, int p_port_id) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node_id);
-	ERR_FAIL_COND(!node.is_valid());
-
-	undo_redo->create_action(TTR("Change output port name"));
-	undo_redo->add_do_method(node.ptr(), "set_output_port_name", p_port_id, p_text);
-	undo_redo->add_undo_method(node.ptr(), "set_output_port_name", p_port_id, node->get_output_port_name(p_port_id));
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_remove_input_port(int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Remove input port"));
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(type, &conns);
-	for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-		int from_node = E->get().from_node;
-		int from_port = E->get().from_port;
-		int to_node = E->get().to_node;
-		int to_port = E->get().to_port;
-
-		if (to_node == p_node) {
-			if (to_port == p_port) {
-				undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port, to_node, to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port, to_node, to_port);
-			} else if (to_port > p_port) {
-				undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port, to_node, to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port, to_node, to_port);
-
-				undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port, to_node, to_port - 1);
-				undo_redo->add_undo_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port, to_node, to_port - 1);
-			}
-		}
-	}
-
-	undo_redo->add_do_method(node.ptr(), "remove_input_port", p_port);
-	undo_redo->add_undo_method(node.ptr(), "add_input_port", p_port, (int)node->get_input_port_type(p_port), node->get_input_port_name(p_port));
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_remove_output_port(int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Remove output port"));
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(type, &conns);
-	for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-		int from_node = E->get().from_node;
-		int from_port = E->get().from_port;
-		int to_node = E->get().to_node;
-		int to_port = E->get().to_port;
-
-		if (from_node == p_node) {
-			if (from_port == p_port) {
-				undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port, to_node, to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port, to_node, to_port);
-			} else if (from_port > p_port) {
-				undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port, to_node, to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port, to_node, to_port);
-
-				undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes_forced", type, from_node, from_port - 1, to_node, to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_port - 1, to_node, to_port);
-			}
-		}
-	}
-
-	undo_redo->add_do_method(node.ptr(), "remove_output_port", p_port);
-	undo_redo->add_undo_method(node.ptr(), "add_output_port", p_port, (int)node->get_output_port_type(p_port), node->get_output_port_name(p_port));
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_expression_focus_out(Object *text_edit, int p_node) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNodeExpression> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	TextEdit *expression_box = Object::cast_to<TextEdit>(text_edit);
-
-	if (node->get_expression() == expression_box->get_text()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Set expression"));
-	undo_redo->add_do_method(node.ptr(), "set_expression", expression_box->get_text());
-	undo_redo->add_undo_method(node.ptr(), "set_expression", node->get_expression());
-	undo_redo->add_do_method(this, "_rebuild");
-	undo_redo->add_undo_method(this, "_rebuild");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_rebuild() {
-	if (visual_shader != nullptr) {
-		EditorNode::get_singleton()->get_log()->clear();
-		visual_shader->rebuild();
-	}
-}
-
-void VisualShaderEditor::_set_node_size(int p_type, int p_node, const Vector2 &p_size) {
-	VisualShader::Type type = VisualShader::Type(p_type);
-	Ref<VisualShaderNode> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	Ref<VisualShaderNodeGroupBase> group_node = Object::cast_to<VisualShaderNodeGroupBase>(node.ptr());
-
-	if (group_node.is_null()) {
-		return;
-	}
-
-	Vector2 size = p_size;
-
-	group_node->set_size(size);
-
-	GraphNode *gn = nullptr;
-	if (edit_type->get_selected() == p_type) { // check - otherwise the error will be emitted
-		Node *node2 = graph->get_node(itos(p_node));
-		gn = Object::cast_to<GraphNode>(node2);
-		if (!gn) {
-			return;
-		}
-
-		gn->set_custom_minimum_size(size);
-		gn->set_size(Size2(1, 1));
-	}
-
-	Ref<VisualShaderNodeExpression> expression_node = Object::cast_to<VisualShaderNodeExpression>(node.ptr());
-	if (!expression_node.is_null()) {
-		Control *text_box = expression_node->get_control(0);
-		Size2 box_size = size;
-		if (gn != nullptr) {
-			if (box_size.x < 150 * EDSCALE || box_size.y < 0) {
-				box_size.x = gn->get_size().x;
-			}
-		}
-		box_size.x -= text_box->get_margin(MARGIN_LEFT);
-		box_size.x -= 28 * EDSCALE;
-		box_size.y -= text_box->get_margin(MARGIN_TOP);
-		box_size.y -= 28 * EDSCALE;
-		text_box->set_custom_minimum_size(Size2(box_size.x, box_size.y));
-		text_box->set_size(Size2(1, 1));
-	}
-}
-
-void VisualShaderEditor::_node_resized(const Vector2 &p_new_size, int p_type, int p_node) {
-	VisualShader::Type type = VisualShader::Type(p_type);
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Resize VisualShader node"), UndoRedo::MERGE_ENDS);
-	undo_redo->add_do_method(this, "_set_node_size", p_type, p_node, p_new_size);
-	undo_redo->add_undo_method(this, "_set_node_size", p_type, p_node, node->get_size());
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_preview_select_port(int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNode> node = visual_shader->get_node(type, p_node);
-	if (node.is_null()) {
-		return;
-	}
-
-	if (node->get_output_port_for_preview() == p_port) {
-		p_port = -1; //toggle it
-	}
-	undo_redo->create_action(TTR("Set Uniform Name"));
-	undo_redo->add_do_method(node.ptr(), "set_output_port_for_preview", p_port);
-	undo_redo->add_undo_method(node.ptr(), "set_output_port_for_preview", node->get_output_port_for_preview());
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_line_edit_changed(const String &p_text, Object *line_edit, int p_node_id) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Ref<VisualShaderNodeUniform> node = visual_shader->get_node(type, p_node_id);
-	ERR_FAIL_COND(!node.is_valid());
-
-	String validated_name = visual_shader->validate_uniform_name(p_text, node);
-
-	updating = true;
-	undo_redo->create_action(TTR("Set Uniform Name"));
-	undo_redo->add_do_method(node.ptr(), "set_uniform_name", validated_name);
-	undo_redo->add_undo_method(node.ptr(), "set_uniform_name", node->get_uniform_name());
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-	updating = false;
-
-	Object::cast_to<LineEdit>(line_edit)->set_text(validated_name);
-}
-
-void VisualShaderEditor::_line_edit_focus_out(Object *line_edit, int p_node_id) {
-	String text = Object::cast_to<LineEdit>(line_edit)->get_text();
-	_line_edit_changed(text, line_edit, p_node_id);
-}
-
-void VisualShaderEditor::_port_name_focus_out(Object *line_edit, int p_node_id, int p_port_id, bool p_output) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Ref<VisualShaderNodeGroupBase> node = visual_shader->get_node(type, p_node_id);
-	ERR_FAIL_COND(!node.is_valid());
-
-	String text = Object::cast_to<LineEdit>(line_edit)->get_text();
-
-	if (!p_output) {
-		if (node->get_input_port_name(p_port_id) == text) {
-			return;
-		}
-	} else {
-		if (node->get_output_port_name(p_port_id) == text) {
-			return;
-		}
-	}
-
-	List<String> input_names;
-	List<String> output_names;
-
-	for (int i = 0; i < node->get_input_port_count(); i++) {
-		if (!p_output && i == p_port_id) {
-			continue;
-		}
-		input_names.push_back(node->get_input_port_name(i));
-	}
-	for (int i = 0; i < node->get_output_port_count(); i++) {
-		if (p_output && i == p_port_id) {
-			continue;
-		}
-		output_names.push_back(node->get_output_port_name(i));
-	}
-
-	String validated_name = visual_shader->validate_port_name(text, input_names, output_names);
-	if (validated_name == "") {
-		if (!p_output) {
-			Object::cast_to<LineEdit>(line_edit)->set_text(node->get_input_port_name(p_port_id));
-		} else {
-			Object::cast_to<LineEdit>(line_edit)->set_text(node->get_output_port_name(p_port_id));
-		}
-		return;
-	}
-
-	if (!p_output) {
-		_change_input_port_name(validated_name, line_edit, p_node_id, p_port_id);
-	} else {
-		_change_output_port_name(validated_name, line_edit, p_node_id, p_port_id);
-	}
-}
-
-void VisualShaderEditor::_port_edited() {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Variant value = property_editor->get_variant();
-	Ref<VisualShaderNode> vsn = visual_shader->get_node(type, editing_node);
-	ERR_FAIL_COND(!vsn.is_valid());
-	undo_redo->create_action(TTR("Set Input Default Port"));
-	Ref<VisualShaderNodeCustom> custom = Object::cast_to<VisualShaderNodeCustom>(vsn.ptr());
-	if (custom.is_valid()) {
-		undo_redo->add_do_method(custom.ptr(), "_set_input_port_default_value", editing_port, value);
-		undo_redo->add_undo_method(custom.ptr(), "_set_input_port_default_value", editing_port, vsn->get_input_port_default_value(editing_port));
-	} else {
-		undo_redo->add_do_method(vsn.ptr(), "set_input_port_default_value", editing_port, value);
-		undo_redo->add_undo_method(vsn.ptr(), "set_input_port_default_value", editing_port, vsn->get_input_port_default_value(editing_port));
-	}
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-
-	property_editor->hide();
-}
-
-void VisualShaderEditor::_edit_port_default_input(Object *p_button, int p_node, int p_port) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	Ref<VisualShaderNode> vsn = visual_shader->get_node(type, p_node);
-
-	Button *button = Object::cast_to<Button>(p_button);
-	ERR_FAIL_COND(!button);
-	Variant value = vsn->get_input_port_default_value(p_port);
-	property_editor->set_global_position(button->get_global_position() + Vector2(0, button->get_size().height));
-	property_editor->edit(nullptr, "", value.get_type(), value, 0, "");
-	property_editor->popup();
-	editing_node = p_node;
-	editing_port = p_port;
-}
-
-void VisualShaderEditor::_add_custom_node(const String &p_path) {
-	int idx = -1;
-
-	for (int i = custom_node_option_idx; i < add_options.size(); i++) {
-		if (add_options[i].script.is_valid()) {
-			if (add_options[i].script->get_path() == p_path) {
-				idx = i;
-				break;
-			}
-		}
-	}
-	if (idx != -1) {
-		_add_node(idx);
-	}
-}
-
-void VisualShaderEditor::_add_texture_node(const String &p_path) {
-	VisualShaderNodeTexture *texture = (VisualShaderNodeTexture *)_add_node(texture_node_option_idx, -1);
-	texture->set_texture(ResourceLoader::load(p_path));
-}
-
-VisualShaderNode *VisualShaderEditor::_add_node(int p_idx, int p_op_idx) {
-	ERR_FAIL_INDEX_V(p_idx, add_options.size(), nullptr);
-
-	Ref<VisualShaderNode> vsnode;
-
-	bool is_custom = add_options[p_idx].is_custom;
-
-	if (!is_custom && add_options[p_idx].type != String()) {
-		VisualShaderNode *vsn = Object::cast_to<VisualShaderNode>(ClassDB::instance(add_options[p_idx].type));
-		ERR_FAIL_COND_V(!vsn, nullptr);
-
-		VisualShaderNodeScalarConstant *constant = Object::cast_to<VisualShaderNodeScalarConstant>(vsn);
-
-		if (constant) {
-			if ((int)add_options[p_idx].value != -1) {
-				constant->set_constant(add_options[p_idx].value);
-			}
-		}
-
-		if (p_op_idx != -1) {
-			VisualShaderNodeInput *input = Object::cast_to<VisualShaderNodeInput>(vsn);
-
-			if (input) {
-				input->set_input_name(add_options[p_idx].sub_func_str);
-			}
-
-			VisualShaderNodeIs *is = Object::cast_to<VisualShaderNodeIs>(vsn);
-
-			if (is) {
-				is->set_function((VisualShaderNodeIs::Function)p_op_idx);
-			}
-
-			VisualShaderNodeCompare *cmp = Object::cast_to<VisualShaderNodeCompare>(vsn);
-
-			if (cmp) {
-				cmp->set_function((VisualShaderNodeCompare::Function)p_op_idx);
-			}
-
-			VisualShaderNodeColorOp *colorOp = Object::cast_to<VisualShaderNodeColorOp>(vsn);
-
-			if (colorOp) {
-				colorOp->set_operator((VisualShaderNodeColorOp::Operator)p_op_idx);
-			}
-
-			VisualShaderNodeColorFunc *colorFunc = Object::cast_to<VisualShaderNodeColorFunc>(vsn);
-
-			if (colorFunc) {
-				colorFunc->set_function((VisualShaderNodeColorFunc::Function)p_op_idx);
-			}
-
-			VisualShaderNodeScalarOp *scalarOp = Object::cast_to<VisualShaderNodeScalarOp>(vsn);
-
-			if (scalarOp) {
-				scalarOp->set_operator((VisualShaderNodeScalarOp::Operator)p_op_idx);
-			}
-
-			VisualShaderNodeScalarFunc *scalarFunc = Object::cast_to<VisualShaderNodeScalarFunc>(vsn);
-
-			if (scalarFunc) {
-				scalarFunc->set_function((VisualShaderNodeScalarFunc::Function)p_op_idx);
-			}
-
-			VisualShaderNodeVectorOp *vecOp = Object::cast_to<VisualShaderNodeVectorOp>(vsn);
-
-			if (vecOp) {
-				vecOp->set_operator((VisualShaderNodeVectorOp::Operator)p_op_idx);
-			}
-
-			VisualShaderNodeVectorFunc *vecFunc = Object::cast_to<VisualShaderNodeVectorFunc>(vsn);
-
-			if (vecFunc) {
-				vecFunc->set_function((VisualShaderNodeVectorFunc::Function)p_op_idx);
-			}
-
-			VisualShaderNodeTransformFunc *matFunc = Object::cast_to<VisualShaderNodeTransformFunc>(vsn);
-
-			if (matFunc) {
-				matFunc->set_function((VisualShaderNodeTransformFunc::Function)p_op_idx);
-			}
-
-			VisualShaderNodeScalarDerivativeFunc *sderFunc = Object::cast_to<VisualShaderNodeScalarDerivativeFunc>(vsn);
-
-			if (sderFunc) {
-				sderFunc->set_function((VisualShaderNodeScalarDerivativeFunc::Function)p_op_idx);
-			}
-
-			VisualShaderNodeVectorDerivativeFunc *vderFunc = Object::cast_to<VisualShaderNodeVectorDerivativeFunc>(vsn);
-
-			if (vderFunc) {
-				vderFunc->set_function((VisualShaderNodeVectorDerivativeFunc::Function)p_op_idx);
-			}
-		}
-
-		vsnode = Ref<VisualShaderNode>(vsn);
-	} else {
-		ERR_FAIL_COND_V(add_options[p_idx].script.is_null(), nullptr);
-		String base_type = add_options[p_idx].script->get_instance_base_type();
-		VisualShaderNode *vsn = Object::cast_to<VisualShaderNode>(ClassDB::instance(base_type));
-		ERR_FAIL_COND_V(!vsn, nullptr);
-		vsnode = Ref<VisualShaderNode>(vsn);
-		vsnode->set_script(add_options[p_idx].script.get_ref_ptr());
-	}
-
-	Point2 position = graph->get_scroll_ofs();
-
-	if (saved_node_pos_dirty) {
-		position += saved_node_pos;
-	} else {
-		position += graph->get_size() * 0.5;
-		position /= EDSCALE;
-	}
-	position /= graph->get_zoom();
-	saved_node_pos_dirty = false;
-
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	int id_to_use = visual_shader->get_valid_node_id(type);
-
-	undo_redo->create_action(TTR("Add Node to Visual Shader"));
-	undo_redo->add_do_method(visual_shader.ptr(), "add_node", type, vsnode, position, id_to_use);
-	undo_redo->add_undo_method(visual_shader.ptr(), "remove_node", type, id_to_use);
-
-	VisualShaderNodeExpression *expr = Object::cast_to<VisualShaderNodeExpression>(vsnode.ptr());
-	if (expr) {
-		undo_redo->add_do_method(expr, "set_size", Size2(250 * EDSCALE, 150 * EDSCALE));
-	}
-
-	if (to_node != -1 && to_slot != -1) {
-		if (vsnode->get_output_port_count() > 0) {
-			int _from_node = id_to_use;
-			int _from_slot = 0;
-
-			if (visual_shader->is_port_types_compatible(vsnode->get_output_port_type(_from_slot), visual_shader->get_node(type, to_node)->get_input_port_type(to_slot))) {
-				undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes", type, _from_node, _from_slot, to_node, to_slot);
-				undo_redo->add_undo_method(visual_shader.ptr(), "disconnect_nodes", type, _from_node, _from_slot, to_node, to_slot);
-			}
-		}
-	} else if (from_node != -1 && from_slot != -1) {
-		if (vsnode->get_input_port_count() > 0) {
-			int _to_node = id_to_use;
-			int _to_slot = 0;
-
-			if (visual_shader->is_port_types_compatible(visual_shader->get_node(type, from_node)->get_output_port_type(from_slot), vsnode->get_input_port_type(_to_slot))) {
-				undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes", type, from_node, from_slot, _to_node, _to_slot);
-				undo_redo->add_undo_method(visual_shader.ptr(), "disconnect_nodes", type, from_node, from_slot, _to_node, _to_slot);
-			}
-		}
-	}
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-	return vsnode.ptr();
-}
-
-void VisualShaderEditor::_node_dragged(const Vector2 &p_from, const Vector2 &p_to, int p_node) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	drag_buffer.push_back({ type, p_node, p_from, p_to });
-	if (!drag_dirty) {
-		call_deferred("_nodes_dragged");
-	}
-	drag_dirty = true;
-}
-
-void VisualShaderEditor::_nodes_dragged() {
-	drag_dirty = false;
-
-	undo_redo->create_action(TTR("Node(s) Moved"));
-
-	for (List<DragOp>::Element *E = drag_buffer.front(); E; E = E->next()) {
-		undo_redo->add_do_method(visual_shader.ptr(), "set_node_position", E->get().type, E->get().node, E->get().to);
-		undo_redo->add_undo_method(visual_shader.ptr(), "set_node_position", E->get().type, E->get().node, E->get().from);
-	}
-	updating = true;
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-
-	drag_buffer.clear();
-	undo_redo->commit_action();
-	updating = false;
-}
-
-void VisualShaderEditor::_connection_request(const String &p_from, int p_from_index, const String &p_to, int p_to_index) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	int from = p_from.to_int();
-	int to = p_to.to_int();
-
-	if (!visual_shader->can_connect_nodes(type, from, p_from_index, to, p_to_index)) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Nodes Connected"));
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(type, &conns);
-
-	for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-		if (E->get().to_node == to && E->get().to_port == p_to_index) {
-			undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-			undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-		}
-	}
-
-	undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes", type, from, p_from_index, to, p_to_index);
-	undo_redo->add_undo_method(visual_shader.ptr(), "disconnect_nodes", type, from, p_from_index, to, p_to_index);
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_disconnection_request(const String &p_from, int p_from_index, const String &p_to, int p_to_index) {
-	graph->disconnect_node(p_from, p_from_index, p_to, p_to_index);
-
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	int from = p_from.to_int();
-	int to = p_to.to_int();
-
-	//updating = true; seems graph edit can handle this, no need to protect
-	undo_redo->create_action(TTR("Nodes Disconnected"));
-	undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, from, p_from_index, to, p_to_index);
-	undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, from, p_from_index, to, p_to_index);
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-	//updating = false;
-}
-
-void VisualShaderEditor::_connection_to_empty(const String &p_from, int p_from_slot, const Vector2 &p_release_position) {
-	from_node = p_from.to_int();
-	from_slot = p_from_slot;
-	_show_members_dialog(true);
-}
-
-void VisualShaderEditor::_connection_from_empty(const String &p_to, int p_to_slot, const Vector2 &p_release_position) {
-	to_node = p_to.to_int();
-	to_slot = p_to_slot;
-	_show_members_dialog(true);
-}
-
-void VisualShaderEditor::_delete_request(int which) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	Ref<VisualShaderNode> node = Ref<VisualShaderNode>(visual_shader->get_node(type, which));
-
-	undo_redo->create_action(TTR("Delete Node"));
-	undo_redo->add_do_method(visual_shader.ptr(), "remove_node", type, which);
-	undo_redo->add_undo_method(visual_shader.ptr(), "add_node", type, node, visual_shader->get_node_position(type, which), which);
-
-	undo_redo->add_do_method(this, "_clear_buffer");
-	undo_redo->add_undo_method(this, "_clear_buffer");
-
-	// restore size, inputs and outputs if node is group
-	VisualShaderNodeGroupBase *group = Object::cast_to<VisualShaderNodeGroupBase>(node.ptr());
-	if (group) {
-		undo_redo->add_undo_method(group, "set_size", group->get_size());
-		undo_redo->add_undo_method(group, "set_inputs", group->get_inputs());
-		undo_redo->add_undo_method(group, "set_outputs", group->get_outputs());
-	}
-
-	// restore expression text if node is expression
-	VisualShaderNodeExpression *expression = Object::cast_to<VisualShaderNodeExpression>(node.ptr());
-	if (expression) {
-		undo_redo->add_undo_method(expression, "set_expression", expression->get_expression());
-	}
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(type, &conns);
-
-	for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-		if (E->get().from_node == which || E->get().to_node == which) {
-			undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-		}
-	}
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_node_selected(Object *p_node) {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-
-	GraphNode *gn = Object::cast_to<GraphNode>(p_node);
-	ERR_FAIL_COND(!gn);
-
-	int id = String(gn->get_name()).to_int();
-
-	Ref<VisualShaderNode> vsnode = visual_shader->get_node(type, id);
-	ERR_FAIL_COND(!vsnode.is_valid());
-
-	//do not rely on this, makes editor more complex
-	//EditorNode::get_singleton()->push_item(vsnode.ptr(), "", true);
-}
-
-void VisualShaderEditor::_graph_gui_input(const Ref<InputEvent> &p_event) {
-	Ref<InputEventMouseButton> mb = p_event;
-
-	if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
-		_show_members_dialog(true);
-	}
-}
-
-void VisualShaderEditor::_show_members_dialog(bool at_mouse_pos) {
-	if (at_mouse_pos) {
-		saved_node_pos_dirty = true;
-		saved_node_pos = graph->get_local_mouse_position();
-
-		Point2 gpos = Input::get_singleton()->get_mouse_position();
-		members_dialog->popup();
-		members_dialog->set_position(gpos);
-	} else {
-		members_dialog->popup();
-		saved_node_pos_dirty = false;
-		members_dialog->set_position(graph->get_global_position() + Point2(5 * EDSCALE, 65 * EDSCALE));
-	}
-
-	// keep dialog within window bounds
-	Size2 window_size = OS::get_singleton()->get_window_size();
-	Rect2 dialog_rect = members_dialog->get_global_rect();
-	if (dialog_rect.position.y + dialog_rect.size.y > window_size.y) {
-		int difference = dialog_rect.position.y + dialog_rect.size.y - window_size.y;
-		members_dialog->set_position(members_dialog->get_position() - Point2(0, difference));
-	}
-	if (dialog_rect.position.x + dialog_rect.size.x > window_size.x) {
-		int difference = dialog_rect.position.x + dialog_rect.size.x - window_size.x;
-		members_dialog->set_position(members_dialog->get_position() - Point2(difference, 0));
-	}
-
-	node_filter->call_deferred("grab_focus"); // still not visible
-	node_filter->select_all();
-}
-
-void VisualShaderEditor::_sbox_input(const Ref<InputEvent> &p_ie) {
-	Ref<InputEventKey> ie = p_ie;
-	if (ie.is_valid() && (ie->get_scancode() == KEY_UP || ie->get_scancode() == KEY_DOWN || ie->get_scancode() == KEY_ENTER || ie->get_scancode() == KEY_KP_ENTER)) {
-		members->call("_gui_input", ie);
-		node_filter->accept_event();
-	}
-}
-
-void VisualShaderEditor::_notification(int p_what) {
-	if (p_what == NOTIFICATION_ENTER_TREE) {
-		node_filter->set_clear_button_enabled(true);
-
-		// collapse tree by default
-
-		TreeItem *category = members->get_root()->get_children();
-		while (category) {
-			category->set_collapsed(true);
-			TreeItem *sub_category = category->get_children();
-			while (sub_category) {
-				sub_category->set_collapsed(true);
-				sub_category = sub_category->get_next();
-			}
-			category = category->get_next();
-		}
-	}
-
-	if (p_what == NOTIFICATION_DRAG_BEGIN) {
-		Dictionary dd = get_viewport()->gui_get_drag_data();
-		if (members->is_visible_in_tree() && dd.has("id")) {
-			members->set_drop_mode_flags(Tree::DROP_MODE_ON_ITEM);
-		}
-	} else if (p_what == NOTIFICATION_DRAG_END) {
-		members->set_drop_mode_flags(0);
-	}
-
-	if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
-		error_panel->add_style_override("panel", get_stylebox("bg", "Tree"));
-		error_label->add_color_override("font_color", get_color("error_color", "Editor"));
-
-		node_filter->set_right_icon(Control::get_icon("Search", "EditorIcons"));
-
-		preview_shader->set_icon(Control::get_icon("Shader", "EditorIcons"));
-
-		{
-			Color background_color = EDITOR_GET("text_editor/highlighting/background_color");
-			Color text_color = EDITOR_GET("text_editor/highlighting/text_color");
-			Color keyword_color = EDITOR_GET("text_editor/highlighting/keyword_color");
-			Color control_flow_keyword_color = EDITOR_GET("text_editor/highlighting/control_flow_keyword_color");
-			Color comment_color = EDITOR_GET("text_editor/highlighting/comment_color");
-			Color symbol_color = EDITOR_GET("text_editor/highlighting/symbol_color");
-
-			preview_text->add_color_override("background_color", background_color);
-
-			for (List<String>::Element *E = keyword_list.front(); E; E = E->next()) {
-				if (ShaderLanguage::is_control_flow_keyword(E->get())) {
-					preview_text->add_keyword_color(E->get(), control_flow_keyword_color);
-				} else {
-					preview_text->add_keyword_color(E->get(), keyword_color);
-				}
-			}
-
-			preview_text->add_font_override("font", get_font("expression", "EditorFonts"));
-			preview_text->add_color_override("font_color", text_color);
-			preview_text->add_color_override("symbol_color", symbol_color);
-			preview_text->add_color_region("/*", "*/", comment_color, false);
-			preview_text->add_color_region("//", "", comment_color, false);
-
-			error_text->add_font_override("font", get_font("status_source", "EditorFonts"));
-			error_text->add_color_override("font_color", get_color("error_color", "Editor"));
-		}
-
-		tools->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("Tools", "EditorIcons"));
-
-		if (p_what == NOTIFICATION_THEME_CHANGED && is_visible_in_tree()) {
-			_update_graph();
-		}
-	}
-}
-
-void VisualShaderEditor::_scroll_changed(const Vector2 &p_scroll) {
-	if (updating) {
-		return;
-	}
-	updating = true;
-	visual_shader->set_graph_offset(p_scroll / EDSCALE);
-	updating = false;
-}
-
-void VisualShaderEditor::_node_changed(int p_id) {
-	if (updating) {
-		return;
-	}
-
-	if (is_visible_in_tree()) {
-		_update_graph();
-	}
-}
-
-void VisualShaderEditor::_dup_update_excluded(int p_type, Set<int> &r_excluded) {
-	r_excluded.clear();
-	VisualShader::Type type = (VisualShader::Type)p_type;
-
-	for (int i = 0; i < graph->get_child_count(); i++) {
-		GraphNode *gn = Object::cast_to<GraphNode>(graph->get_child(i));
-		if (gn) {
-			int id = String(gn->get_name()).to_int();
-			Ref<VisualShaderNode> node = visual_shader->get_node(type, id);
-			Ref<VisualShaderNodeOutput> output = node;
-			if (output.is_valid()) {
-				r_excluded.insert(id);
-				continue;
-			}
-			r_excluded.insert(id);
-		}
-	}
-}
-
-void VisualShaderEditor::_dup_copy_nodes(int p_type, List<int> &r_nodes, Set<int> &r_excluded) {
-	VisualShader::Type type = (VisualShader::Type)p_type;
-
-	selection_center.x = 0.0f;
-	selection_center.y = 0.0f;
-
-	for (int i = 0; i < graph->get_child_count(); i++) {
-		GraphNode *gn = Object::cast_to<GraphNode>(graph->get_child(i));
-		if (gn) {
-			int id = String(gn->get_name()).to_int();
-			Ref<VisualShaderNode> node = visual_shader->get_node(type, id);
-			Ref<VisualShaderNodeOutput> output = node;
-			if (output.is_valid()) { // can't duplicate output
-				r_excluded.insert(id);
-				continue;
-			}
-			if (node.is_valid() && gn->is_selected()) {
-				Vector2 pos = visual_shader->get_node_position(type, id);
-				selection_center += pos;
-				r_nodes.push_back(id);
-			}
-			r_excluded.insert(id);
-		}
-	}
-
-	selection_center /= (float)r_nodes.size();
-}
-
-void VisualShaderEditor::_dup_paste_nodes(int p_type, int p_pasted_type, List<int> &r_nodes, Set<int> &r_excluded, const Vector2 &p_offset, bool p_select) {
-	VisualShader::Type type = (VisualShader::Type)p_type;
-	VisualShader::Type pasted_type = (VisualShader::Type)p_pasted_type;
-
-	int base_id = visual_shader->get_valid_node_id(type);
-	int id_from = base_id;
-	Map<int, int> connection_remap;
-	Set<int> unsupported_set;
-
-	for (List<int>::Element *E = r_nodes.front(); E; E = E->next()) {
-		connection_remap[E->get()] = id_from;
-		Ref<VisualShaderNode> node = visual_shader->get_node(pasted_type, E->get());
-
-		bool unsupported = false;
-		for (int i = 0; i < add_options.size(); i++) {
-			if (add_options[i].type == node->get_class_name()) {
-				if (!_is_available(add_options[i].mode)) {
-					unsupported = true;
-				}
-				break;
-			}
-		}
-		if (unsupported) {
-			unsupported_set.insert(E->get());
-			continue;
-		}
-
-		Ref<VisualShaderNode> dupli = node->duplicate();
-
-		undo_redo->add_do_method(visual_shader.ptr(), "add_node", type, dupli, visual_shader->get_node_position(pasted_type, E->get()) + p_offset, id_from);
-		undo_redo->add_undo_method(visual_shader.ptr(), "remove_node", type, id_from);
-
-		// duplicate size, inputs and outputs if node is group
-		Ref<VisualShaderNodeGroupBase> group = Object::cast_to<VisualShaderNodeGroupBase>(node.ptr());
-		if (!group.is_null()) {
-			undo_redo->add_do_method(dupli.ptr(), "set_size", group->get_size());
-			undo_redo->add_do_method(dupli.ptr(), "set_inputs", group->get_inputs());
-			undo_redo->add_do_method(dupli.ptr(), "set_outputs", group->get_outputs());
-		}
-		// duplicate expression text if node is expression
-		Ref<VisualShaderNodeExpression> expression = Object::cast_to<VisualShaderNodeExpression>(node.ptr());
-		if (!expression.is_null()) {
-			undo_redo->add_do_method(dupli.ptr(), "set_expression", expression->get_expression());
-		}
-
-		id_from++;
-	}
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(pasted_type, &conns);
-
-	for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-		if (unsupported_set.has(E->get().from_node) || unsupported_set.has(E->get().to_node)) {
-			continue;
-		}
-		if (connection_remap.has(E->get().from_node) && connection_remap.has(E->get().to_node)) {
-			undo_redo->add_do_method(visual_shader.ptr(), "connect_nodes_forced", type, connection_remap[E->get().from_node], E->get().from_port, connection_remap[E->get().to_node], E->get().to_port);
-		}
-	}
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-
-	if (p_select) {
-		// reselect duplicated nodes by excluding the other ones
-		for (int i = 0; i < graph->get_child_count(); i++) {
-			GraphNode *gn = Object::cast_to<GraphNode>(graph->get_child(i));
-			if (gn) {
-				int id = String(gn->get_name()).to_int();
-				if (!r_excluded.has(id)) {
-					gn->set_selected(true);
-				} else {
-					gn->set_selected(false);
-				}
-			}
-		}
-	}
-}
-
-void VisualShaderEditor::_clear_buffer() {
-	copy_nodes_buffer.clear();
-	copy_nodes_excluded_buffer.clear();
-}
-
-void VisualShaderEditor::_duplicate_nodes() {
-	int type = edit_type->get_selected();
-
-	List<int> nodes;
-	Set<int> excluded;
-
-	_dup_copy_nodes(type, nodes, excluded);
-
-	if (nodes.empty()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Duplicate Nodes"));
-
-	_dup_paste_nodes(type, type, nodes, excluded, Vector2(10, 10) * EDSCALE, true);
-}
-
-void VisualShaderEditor::_copy_nodes() {
-	copy_type = edit_type->get_selected();
-
-	_clear_buffer();
-
-	_dup_copy_nodes(copy_type, copy_nodes_buffer, copy_nodes_excluded_buffer);
-}
-
-void VisualShaderEditor::_paste_nodes() {
-	if (copy_nodes_buffer.empty()) {
-		return;
-	}
-
-	int type = edit_type->get_selected();
-
-	undo_redo->create_action(TTR("Paste Nodes"));
-
-	float scale = graph->get_zoom();
-
-	_dup_paste_nodes(type, copy_type, copy_nodes_buffer, copy_nodes_excluded_buffer, (graph->get_scroll_ofs() / scale + graph->get_local_mouse_position() / scale - selection_center), false);
-
-	_dup_update_excluded(type, copy_nodes_excluded_buffer); // to prevent selection of previous copies at new paste
-}
-
-void VisualShaderEditor::_on_nodes_delete() {
-	VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-	List<int> to_erase;
-
-	for (int i = 0; i < graph->get_child_count(); i++) {
-		GraphNode *gn = Object::cast_to<GraphNode>(graph->get_child(i));
-		if (gn) {
-			if (gn->is_selected() && gn->is_close_button_visible()) {
-				to_erase.push_back(gn->get_name().operator String().to_int());
-			}
-		}
-	}
-
-	if (to_erase.empty()) {
-		return;
-	}
-
-	undo_redo->create_action(TTR("Delete Nodes"));
-
-	for (List<int>::Element *F = to_erase.front(); F; F = F->next()) {
-		Ref<VisualShaderNode> node = visual_shader->get_node(type, F->get());
-
-		undo_redo->add_do_method(visual_shader.ptr(), "remove_node", type, F->get());
-		undo_redo->add_undo_method(visual_shader.ptr(), "add_node", type, node, visual_shader->get_node_position(type, F->get()), F->get());
-
-		undo_redo->add_do_method(this, "_clear_buffer");
-		undo_redo->add_undo_method(this, "_clear_buffer");
-
-		// restore size, inputs and outputs if node is group
-		VisualShaderNodeGroupBase *group = Object::cast_to<VisualShaderNodeGroupBase>(node.ptr());
-		if (group) {
-			undo_redo->add_undo_method(group, "set_size", group->get_size());
-			undo_redo->add_undo_method(group, "set_inputs", group->get_inputs());
-			undo_redo->add_undo_method(group, "set_outputs", group->get_outputs());
-		}
-
-		// restore expression text if node is expression
-		VisualShaderNodeExpression *expression = Object::cast_to<VisualShaderNodeExpression>(node.ptr());
-		if (expression) {
-			undo_redo->add_undo_method(expression, "set_expression", expression->get_expression());
-		}
-	}
-
-	List<VisualShader::Connection> conns;
-	visual_shader->get_node_connections(type, &conns);
-
-	List<VisualShader::Connection> used_conns;
-	for (List<int>::Element *F = to_erase.front(); F; F = F->next()) {
-		for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-			if (E->get().from_node == F->get() || E->get().to_node == F->get()) {
-				bool cancel = false;
-				for (List<VisualShader::Connection>::Element *R = used_conns.front(); R; R = R->next()) {
-					if (R->get().from_node == E->get().from_node && R->get().from_port == E->get().from_port && R->get().to_node == E->get().to_node && R->get().to_port == E->get().to_port) {
-						cancel = true; // to avoid ERR_ALREADY_EXISTS warning
-						break;
-					}
-				}
-				if (!cancel) {
-					undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-					used_conns.push_back(E->get());
-				}
-			}
-		}
-	}
-
-	undo_redo->add_do_method(this, "_update_graph");
-	undo_redo->add_undo_method(this, "_update_graph");
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_mode_selected(int p_id) {
-	_update_options_menu();
-	_update_graph();
-}
-
-void VisualShaderEditor::_input_select_item(Ref<VisualShaderNodeInput> input, String name) {
-	String prev_name = input->get_input_name();
-
-	if (name == prev_name) {
-		return;
-	}
-
-	bool type_changed = input->get_input_type_by_name(name) != input->get_input_type_by_name(prev_name);
-
-	UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
-	undo_redo->create_action(TTR("Visual Shader Input Type Changed"));
-
-	undo_redo->add_do_method(input.ptr(), "set_input_name", name);
-	undo_redo->add_undo_method(input.ptr(), "set_input_name", prev_name);
-
-	if (type_changed) {
-		//restore connections if type changed
-		VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-		int id = visual_shader->find_node_id(type, input);
-		List<VisualShader::Connection> conns;
-		visual_shader->get_node_connections(type, &conns);
-		for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-			if (E->get().from_node == id) {
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-			}
-		}
-	}
-
-	undo_redo->add_do_method(VisualShaderEditor::get_singleton(), "_update_graph");
-	undo_redo->add_undo_method(VisualShaderEditor::get_singleton(), "_update_graph");
-
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_uniform_select_item(Ref<VisualShaderNodeUniformRef> p_uniform_ref, String p_name) {
-	String prev_name = p_uniform_ref->get_uniform_name();
-
-	if (p_name == prev_name) {
-		return;
-	}
-
-	bool type_changed = p_uniform_ref->get_uniform_type_by_name(p_name) != p_uniform_ref->get_uniform_type_by_name(prev_name);
-
-	UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
-	undo_redo->create_action(TTR("UniformRef Name Changed"));
-
-	undo_redo->add_do_method(p_uniform_ref.ptr(), "set_uniform_name", p_name);
-	undo_redo->add_undo_method(p_uniform_ref.ptr(), "set_uniform_name", prev_name);
-
-	if (type_changed) {
-		//restore connections if type changed
-		VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
-		int id = visual_shader->find_node_id(type, p_uniform_ref);
-		List<VisualShader::Connection> conns;
-		visual_shader->get_node_connections(type, &conns);
-		for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-			if (E->get().from_node == id) {
-				undo_redo->add_do_method(visual_shader.ptr(), "disconnect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-			}
-		}
-	}
-
-	undo_redo->add_do_method(VisualShaderEditor::get_singleton(), "_update_graph");
-	undo_redo->add_undo_method(VisualShaderEditor::get_singleton(), "_update_graph");
-
-	undo_redo->commit_action();
-}
-
-void VisualShaderEditor::_member_filter_changed(const String &p_text) {
-	_update_options_menu();
-}
-
-void VisualShaderEditor::_member_selected() {
-	TreeItem *item = members->get_selected();
-
-	if (item != nullptr && item->has_meta("id")) {
-		members_dialog->get_ok()->set_disabled(false);
-		node_desc->set_text(_get_description(item->get_meta("id")));
-	} else {
-		members_dialog->get_ok()->set_disabled(true);
-		node_desc->set_text("");
-	}
-}
-
-void VisualShaderEditor::_member_unselected() {
-}
-
-void VisualShaderEditor::_member_create() {
-	TreeItem *item = members->get_selected();
-	if (item != nullptr && item->has_meta("id")) {
-		int idx = members->get_selected()->get_meta("id");
-		_add_node(idx, add_options[idx].sub_func);
-		members_dialog->hide();
-	}
-}
-
-void VisualShaderEditor::_member_cancel() {
-	to_node = -1;
-	to_slot = -1;
-	from_node = -1;
-	from_slot = -1;
-}
-
-void VisualShaderEditor::_tools_menu_option(int p_idx) {
-	TreeItem *category = members->get_root()->get_children();
-
-	switch (p_idx) {
-		case EXPAND_ALL:
-
-			while (category) {
-				category->set_collapsed(false);
-				TreeItem *sub_category = category->get_children();
-				while (sub_category) {
-					sub_category->set_collapsed(false);
-					sub_category = sub_category->get_next();
-				}
-				category = category->get_next();
-			}
-
-			break;
-
-		case COLLAPSE_ALL:
-
-			while (category) {
-				category->set_collapsed(true);
-				TreeItem *sub_category = category->get_children();
-				while (sub_category) {
-					sub_category->set_collapsed(true);
-					sub_category = sub_category->get_next();
-				}
-				category = category->get_next();
-			}
-
-			break;
-		default:
-			break;
-	}
-}
-
-Variant VisualShaderEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
-	if (p_from == members) {
-		TreeItem *it = members->get_item_at_position(p_point);
-		if (!it) {
-			return Variant();
-		}
-		if (!it->has_meta("id")) {
-			return Variant();
-		}
-
-		int id = it->get_meta("id");
-		AddOption op = add_options[id];
-
-		Dictionary d;
-		d["id"] = id;
-		if (op.sub_func == -1) {
-			d["sub_func"] = op.sub_func_str;
-		} else {
-			d["sub_func"] = op.sub_func;
-		}
-
-		Label *label = memnew(Label);
-		label->set_text(it->get_text(0));
-		set_drag_preview(label);
-		return d;
-	}
-	return Variant();
-}
-
-bool VisualShaderEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
-	if (p_from == graph) {
-		Dictionary d = p_data;
-
-		if (d.has("id")) {
-			return true;
-		}
-		if (d.has("files")) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-void VisualShaderEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
-	if (p_from == graph) {
-		Dictionary d = p_data;
-
-		if (d.has("id")) {
-			int idx = d["id"];
-			saved_node_pos = p_point;
-			saved_node_pos_dirty = true;
-			_add_node(idx, add_options[idx].sub_func);
-		} else if (d.has("files")) {
-			if (d["files"].get_type() == Variant::POOL_STRING_ARRAY) {
-				int j = 0;
-				PoolStringArray arr = d["files"];
-				for (int i = 0; i < arr.size(); i++) {
-					String type = ResourceLoader::get_resource_type(arr[i]);
-					if (type == "GDScript") {
-						Ref<Script> script = ResourceLoader::load(arr[i]);
-						if (script->get_instance_base_type() == "VisualShaderNodeCustom") {
-							saved_node_pos = p_point + Vector2(0, j * 210 * EDSCALE);
-							saved_node_pos_dirty = true;
-							_add_custom_node(arr[i]);
-							j++;
-						}
-					} else if (ClassDB::get_parent_class(type) == "Texture") {
-						saved_node_pos = p_point + Vector2(0, j * 210 * EDSCALE);
-						saved_node_pos_dirty = true;
-						_add_texture_node(arr[i]);
-						j++;
-					}
-				}
-			}
-		}
-	}
-}
-
-void VisualShaderEditor::_show_preview_text() {
-	preview_showed = !preview_showed;
-	preview_vbox->set_visible(preview_showed);
-	if (preview_showed) {
-		if (pending_update_preview) {
-			_update_preview();
-			pending_update_preview = false;
-		}
-	}
-}
-
-void VisualShaderEditor::_update_preview() {
-	if (!preview_showed) {
-		pending_update_preview = true;
-		return;
-	}
-
-	String code = visual_shader->get_code();
-
-	preview_text->set_text(code);
-
-	ShaderLanguage sl;
-
-	Error err = sl.compile(code, ShaderTypes::get_singleton()->get_functions(VisualServer::ShaderMode(visual_shader->get_mode())), ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(visual_shader->get_mode())), ShaderTypes::get_singleton()->get_types());
-
-	for (int i = 0; i < preview_text->get_line_count(); i++) {
-		preview_text->set_line_as_marked(i, false);
-	}
-	if (err != OK) {
-		preview_text->set_line_as_marked(sl.get_error_line() - 1, true);
-		error_text->set_visible(true);
-
-		String text = "error(" + itos(sl.get_error_line()) + "): " + sl.get_error_text();
-		error_text->set_text(text);
-		shader_error = true;
-	} else {
-		error_text->set_visible(false);
-		shader_error = false;
-	}
-}
-
-void VisualShaderEditor::_bind_methods() {
-	ClassDB::bind_method("_rebuild", &VisualShaderEditor::_rebuild);
-	ClassDB::bind_method("_update_graph", &VisualShaderEditor::_update_graph);
-	ClassDB::bind_method("_update_options_menu", &VisualShaderEditor::_update_options_menu);
-	ClassDB::bind_method("_expression_focus_out", &VisualShaderEditor::_expression_focus_out);
-	ClassDB::bind_method("_add_node", &VisualShaderEditor::_add_node);
-	ClassDB::bind_method("_node_dragged", &VisualShaderEditor::_node_dragged);
-	ClassDB::bind_method("_connection_request", &VisualShaderEditor::_connection_request);
-	ClassDB::bind_method("_disconnection_request", &VisualShaderEditor::_disconnection_request);
-	ClassDB::bind_method("_node_selected", &VisualShaderEditor::_node_selected);
-	ClassDB::bind_method("_scroll_changed", &VisualShaderEditor::_scroll_changed);
-	ClassDB::bind_method("_delete_request", &VisualShaderEditor::_delete_request);
-	ClassDB::bind_method("_on_nodes_delete", &VisualShaderEditor::_on_nodes_delete);
-	ClassDB::bind_method("_node_changed", &VisualShaderEditor::_node_changed);
-	ClassDB::bind_method("_edit_port_default_input", &VisualShaderEditor::_edit_port_default_input);
-	ClassDB::bind_method("_port_edited", &VisualShaderEditor::_port_edited);
-	ClassDB::bind_method("_connection_to_empty", &VisualShaderEditor::_connection_to_empty);
-	ClassDB::bind_method("_connection_from_empty", &VisualShaderEditor::_connection_from_empty);
-	ClassDB::bind_method("_line_edit_focus_out", &VisualShaderEditor::_line_edit_focus_out);
-	ClassDB::bind_method("_line_edit_changed", &VisualShaderEditor::_line_edit_changed);
-	ClassDB::bind_method("_port_name_focus_out", &VisualShaderEditor::_port_name_focus_out);
-	ClassDB::bind_method("_duplicate_nodes", &VisualShaderEditor::_duplicate_nodes);
-	ClassDB::bind_method("_copy_nodes", &VisualShaderEditor::_copy_nodes);
-	ClassDB::bind_method("_paste_nodes", &VisualShaderEditor::_paste_nodes);
-	ClassDB::bind_method("_mode_selected", &VisualShaderEditor::_mode_selected);
-	ClassDB::bind_method("_input_select_item", &VisualShaderEditor::_input_select_item);
-	ClassDB::bind_method("_uniform_select_item", &VisualShaderEditor::_uniform_select_item);
-	ClassDB::bind_method("_preview_select_port", &VisualShaderEditor::_preview_select_port);
-	ClassDB::bind_method("_graph_gui_input", &VisualShaderEditor::_graph_gui_input);
-	ClassDB::bind_method("_add_input_port", &VisualShaderEditor::_add_input_port);
-	ClassDB::bind_method("_change_input_port_type", &VisualShaderEditor::_change_input_port_type);
-	ClassDB::bind_method("_change_input_port_name", &VisualShaderEditor::_change_input_port_name);
-	ClassDB::bind_method("_remove_input_port", &VisualShaderEditor::_remove_input_port);
-	ClassDB::bind_method("_add_output_port", &VisualShaderEditor::_add_output_port);
-	ClassDB::bind_method("_change_output_port_type", &VisualShaderEditor::_change_output_port_type);
-	ClassDB::bind_method("_change_output_port_name", &VisualShaderEditor::_change_output_port_name);
-	ClassDB::bind_method("_remove_output_port", &VisualShaderEditor::_remove_output_port);
-	ClassDB::bind_method("_node_resized", &VisualShaderEditor::_node_resized);
-	ClassDB::bind_method("_set_node_size", &VisualShaderEditor::_set_node_size);
-	ClassDB::bind_method("_clear_buffer", &VisualShaderEditor::_clear_buffer);
-	ClassDB::bind_method("_show_preview_text", &VisualShaderEditor::_show_preview_text);
-	ClassDB::bind_method("_update_preview", &VisualShaderEditor::_update_preview);
-	ClassDB::bind_method("_nodes_dragged", &VisualShaderEditor::_nodes_dragged);
-
-	ClassDB::bind_method(D_METHOD("get_drag_data_fw"), &VisualShaderEditor::get_drag_data_fw);
-	ClassDB::bind_method(D_METHOD("can_drop_data_fw"), &VisualShaderEditor::can_drop_data_fw);
-	ClassDB::bind_method(D_METHOD("drop_data_fw"), &VisualShaderEditor::drop_data_fw);
-
-	ClassDB::bind_method("_is_available", &VisualShaderEditor::_is_available);
-	ClassDB::bind_method("_tools_menu_option", &VisualShaderEditor::_tools_menu_option);
-	ClassDB::bind_method("_show_members_dialog", &VisualShaderEditor::_show_members_dialog);
-	ClassDB::bind_method("_sbox_input", &VisualShaderEditor::_sbox_input);
-	ClassDB::bind_method("_member_filter_changed", &VisualShaderEditor::_member_filter_changed);
-	ClassDB::bind_method("_member_selected", &VisualShaderEditor::_member_selected);
-	ClassDB::bind_method("_member_unselected", &VisualShaderEditor::_member_unselected);
-	ClassDB::bind_method("_member_create", &VisualShaderEditor::_member_create);
-	ClassDB::bind_method("_member_cancel", &VisualShaderEditor::_member_cancel);
-}
-
-VisualShaderEditor *VisualShaderEditor::singleton = nullptr;
-
-VisualShaderEditor::VisualShaderEditor() {
-	singleton = this;
-	updating = false;
-	saved_node_pos_dirty = false;
-	saved_node_pos = Point2(0, 0);
-	ShaderLanguage::get_keyword_list(&keyword_list);
-
-	preview_showed = false;
-	pending_update_preview = false;
-	shader_error = false;
-
-	to_node = -1;
-	to_slot = -1;
-	from_node = -1;
-	from_slot = -1;
-
-	main_box = memnew(HSplitContainer);
-	main_box->set_v_size_flags(SIZE_EXPAND_FILL);
-	main_box->set_h_size_flags(SIZE_EXPAND_FILL);
-	add_child(main_box);
-
-	graph = memnew(GraphEdit);
-	graph->get_zoom_hbox()->set_h_size_flags(SIZE_EXPAND_FILL);
-	graph->set_v_size_flags(SIZE_EXPAND_FILL);
-	graph->set_h_size_flags(SIZE_EXPAND_FILL);
-	main_box->add_child(graph);
-	graph->set_drag_forwarding(this);
-	float graph_minimap_opacity = EditorSettings::get_singleton()->get("editors/visual_editors/minimap_opacity");
-	graph->set_minimap_opacity(graph_minimap_opacity);
-	graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_SCALAR);
-	graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_BOOLEAN);
-	graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_VECTOR);
-	graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_TRANSFORM);
-	graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_SAMPLER);
-	//graph->add_valid_left_disconnect_type(0);
-	graph->set_v_size_flags(SIZE_EXPAND_FILL);
-	graph->connect("connection_request", this, "_connection_request", varray(), CONNECT_DEFERRED);
-	graph->connect("disconnection_request", this, "_disconnection_request", varray(), CONNECT_DEFERRED);
-	graph->connect("node_selected", this, "_node_selected");
-	graph->connect("scroll_offset_changed", this, "_scroll_changed");
-	graph->connect("duplicate_nodes_request", this, "_duplicate_nodes");
-	graph->connect("copy_nodes_request", this, "_copy_nodes");
-	graph->connect("paste_nodes_request", this, "_paste_nodes");
-	graph->connect("delete_nodes_request", this, "_on_nodes_delete");
-	graph->connect("gui_input", this, "_graph_gui_input");
-	graph->connect("connection_to_empty", this, "_connection_to_empty");
-	graph->connect("connection_from_empty", this, "_connection_from_empty");
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SCALAR, VisualShaderNode::PORT_TYPE_SCALAR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SCALAR, VisualShaderNode::PORT_TYPE_VECTOR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SCALAR, VisualShaderNode::PORT_TYPE_BOOLEAN);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_VECTOR, VisualShaderNode::PORT_TYPE_SCALAR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_VECTOR, VisualShaderNode::PORT_TYPE_VECTOR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_VECTOR, VisualShaderNode::PORT_TYPE_BOOLEAN);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_BOOLEAN, VisualShaderNode::PORT_TYPE_SCALAR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_BOOLEAN, VisualShaderNode::PORT_TYPE_VECTOR);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_BOOLEAN, VisualShaderNode::PORT_TYPE_BOOLEAN);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShaderNode::PORT_TYPE_TRANSFORM);
-	graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SAMPLER, VisualShaderNode::PORT_TYPE_SAMPLER);
-
-	VSeparator *vs = memnew(VSeparator);
-	graph->get_zoom_hbox()->add_child(vs);
-	graph->get_zoom_hbox()->move_child(vs, 0);
-
-	edit_type = memnew(OptionButton);
-	edit_type->add_item(TTR("Vertex"));
-	edit_type->add_item(TTR("Fragment"));
-	edit_type->add_item(TTR("Light"));
-	edit_type->select(1);
-	edit_type->connect("item_selected", this, "_mode_selected");
-	graph->get_zoom_hbox()->add_child(edit_type);
-	graph->get_zoom_hbox()->move_child(edit_type, 0);
-
-	add_node = memnew(ToolButton);
-	graph->get_zoom_hbox()->add_child(add_node);
-	add_node->set_text(TTR("Add Node..."));
-	graph->get_zoom_hbox()->move_child(add_node, 0);
-	add_node->connect("pressed", this, "_show_members_dialog", varray(false));
-
-	preview_shader = memnew(ToolButton);
-	preview_shader->set_toggle_mode(true);
-	preview_shader->set_tooltip(TTR("Show resulted shader code."));
-	graph->get_zoom_hbox()->add_child(preview_shader);
-	preview_shader->connect("pressed", this, "_show_preview_text");
-
-	///////////////////////////////////////
-	// PREVIEW PANEL
-	///////////////////////////////////////
-
-	preview_vbox = memnew(VBoxContainer);
-	preview_vbox->set_visible(preview_showed);
-	main_box->add_child(preview_vbox);
-	preview_text = memnew(TextEdit);
-	preview_vbox->add_child(preview_text);
-	preview_text->set_h_size_flags(SIZE_EXPAND_FILL);
-	preview_text->set_v_size_flags(SIZE_EXPAND_FILL);
-	preview_text->set_custom_minimum_size(Size2(400 * EDSCALE, 0));
-	preview_text->set_syntax_coloring(true);
-	preview_text->set_show_line_numbers(true);
-	preview_text->set_readonly(true);
-
-	error_text = memnew(Label);
-	preview_vbox->add_child(error_text);
-	error_text->set_visible(false);
-
-	///////////////////////////////////////
-	// SHADER NODES TREE
-	///////////////////////////////////////
-
-	VBoxContainer *members_vb = memnew(VBoxContainer);
-	members_vb->set_v_size_flags(SIZE_EXPAND_FILL);
-
-	HBoxContainer *filter_hb = memnew(HBoxContainer);
-	members_vb->add_child(filter_hb);
-
-	node_filter = memnew(LineEdit);
-	filter_hb->add_child(node_filter);
-	node_filter->connect("text_changed", this, "_member_filter_changed");
-	node_filter->connect("gui_input", this, "_sbox_input");
-	node_filter->set_h_size_flags(SIZE_EXPAND_FILL);
-	node_filter->set_placeholder(TTR("Search"));
-
-	tools = memnew(MenuButton);
-	filter_hb->add_child(tools);
-	tools->set_tooltip(TTR("Options"));
-	tools->get_popup()->connect("id_pressed", this, "_tools_menu_option");
-	tools->get_popup()->add_item(TTR("Expand All"), EXPAND_ALL);
-	tools->get_popup()->add_item(TTR("Collapse All"), COLLAPSE_ALL);
-
-	members = memnew(Tree);
-	members_vb->add_child(members);
-	members->set_drag_forwarding(this);
-	members->set_h_size_flags(SIZE_EXPAND_FILL);
-	members->set_v_size_flags(SIZE_EXPAND_FILL);
-	members->set_hide_root(true);
-	members->set_allow_reselect(true);
-	members->set_hide_folding(false);
-	members->set_custom_minimum_size(Size2(180 * EDSCALE, 200 * EDSCALE));
-	members->connect("item_activated", this, "_member_create");
-	members->connect("item_selected", this, "_member_selected");
-	members->connect("nothing_selected", this, "_member_unselected");
-
-	Label *desc_label = memnew(Label);
-	members_vb->add_child(desc_label);
-	desc_label->set_text(TTR("Description:"));
-
-	node_desc = memnew(RichTextLabel);
-	members_vb->add_child(node_desc);
-	node_desc->set_h_size_flags(SIZE_EXPAND_FILL);
-	node_desc->set_v_size_flags(SIZE_FILL);
-	node_desc->set_custom_minimum_size(Size2(0, 70 * EDSCALE));
-
-	members_dialog = memnew(ConfirmationDialog);
-	members_dialog->set_title(TTR("Create Shader Node"));
-	members_dialog->add_child(members_vb);
-	members_dialog->get_ok()->set_text(TTR("Create"));
-	members_dialog->get_ok()->connect("pressed", this, "_member_create");
-	members_dialog->get_ok()->set_disabled(true);
-	members_dialog->set_resizable(true);
-	members_dialog->set_as_minsize();
-	members_dialog->connect("hide", this, "_member_cancel");
-	add_child(members_dialog);
-
-	alert = memnew(AcceptDialog);
-	alert->set_as_minsize();
-	alert->get_label()->set_autowrap(true);
-	alert->get_label()->set_align(Label::ALIGN_CENTER);
-	alert->get_label()->set_valign(Label::VALIGN_CENTER);
-	alert->get_label()->set_custom_minimum_size(Size2(400, 60) * EDSCALE);
-	add_child(alert);
-
-	///////////////////////////////////////
-	// SHADER NODES TREE OPTIONS
-	///////////////////////////////////////
-
-	// COLOR
-
-	add_options.push_back(AddOption("ColorFunc", "Color", "Common", "VisualShaderNodeColorFunc", TTR("Color function."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ColorOp", "Color", "Common", "VisualShaderNodeColorOp", TTR("Color operator."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("Grayscale", "Color", "Functions", "VisualShaderNodeColorFunc", TTR("Grayscale function."), VisualShaderNodeColorFunc::FUNC_GRAYSCALE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("HSV2RGB", "Color", "Functions", "VisualShaderNodeVectorFunc", TTR("Converts HSV vector to RGB equivalent."), VisualShaderNodeVectorFunc::FUNC_HSV2RGB, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("RGB2HSV", "Color", "Functions", "VisualShaderNodeVectorFunc", TTR("Converts RGB vector to HSV equivalent."), VisualShaderNodeVectorFunc::FUNC_RGB2HSV, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Sepia", "Color", "Functions", "VisualShaderNodeColorFunc", TTR("Sepia function."), VisualShaderNodeColorFunc::FUNC_SEPIA, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("Burn", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Burn operator."), VisualShaderNodeColorOp::OP_BURN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Darken", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Darken operator."), VisualShaderNodeColorOp::OP_DARKEN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Difference", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Difference operator."), VisualShaderNodeColorOp::OP_DIFFERENCE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Dodge", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Dodge operator."), VisualShaderNodeColorOp::OP_DODGE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("HardLight", "Color", "Operators", "VisualShaderNodeColorOp", TTR("HardLight operator."), VisualShaderNodeColorOp::OP_HARD_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Lighten", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Lighten operator."), VisualShaderNodeColorOp::OP_LIGHTEN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Overlay", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Overlay operator."), VisualShaderNodeColorOp::OP_OVERLAY, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Screen", "Color", "Operators", "VisualShaderNodeColorOp", TTR("Screen operator."), VisualShaderNodeColorOp::OP_SCREEN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("SoftLight", "Color", "Operators", "VisualShaderNodeColorOp", TTR("SoftLight operator."), VisualShaderNodeColorOp::OP_SOFT_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("ColorConstant", "Color", "Variables", "VisualShaderNodeColorConstant", TTR("Color constant."), -1, -1));
-	add_options.push_back(AddOption("ColorUniform", "Color", "Variables", "VisualShaderNodeColorUniform", TTR("Color uniform."), -1, -1));
-
-	// CONDITIONAL
-
-	const String &compare_func_desc = TTR("Returns the boolean result of the %s comparison between two parameters.");
-
-	add_options.push_back(AddOption("Equal", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Equal (==)")), VisualShaderNodeCompare::FUNC_EQUAL, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("GreaterThan", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Greater Than (>)")), VisualShaderNodeCompare::FUNC_GREATER_THAN, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("GreaterThanEqual", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Greater Than or Equal (>=)")), VisualShaderNodeCompare::FUNC_GREATER_THAN_EQUAL, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("If", "Conditional", "Functions", "VisualShaderNodeIf", TTR("Returns an associated vector if the provided scalars are equal, greater or less."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("IsInf", "Conditional", "Functions", "VisualShaderNodeIs", TTR("Returns the boolean result of the comparison between INF and a scalar parameter."), VisualShaderNodeIs::FUNC_IS_INF, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("IsNaN", "Conditional", "Functions", "VisualShaderNodeIs", TTR("Returns the boolean result of the comparison between NaN and a scalar parameter."), VisualShaderNodeIs::FUNC_IS_NAN, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("LessThan", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Less Than (<)")), VisualShaderNodeCompare::FUNC_LESS_THAN, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("LessThanEqual", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Less Than or Equal (<=)")), VisualShaderNodeCompare::FUNC_LESS_THAN_EQUAL, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("NotEqual", "Conditional", "Functions", "VisualShaderNodeCompare", vformat(compare_func_desc, TTR("Not Equal (!=)")), VisualShaderNodeCompare::FUNC_NOT_EQUAL, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("Switch", "Conditional", "Functions", "VisualShaderNodeSwitch", TTR("Returns an associated vector if the provided boolean value is true or false."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("SwitchS", "Conditional", "Functions", "VisualShaderNodeScalarSwitch", TTR("Returns an associated scalar if the provided boolean value is true or false."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-
-	add_options.push_back(AddOption("Compare", "Conditional", "Common", "VisualShaderNodeCompare", TTR("Returns the boolean result of the comparison between two parameters."), -1, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("Is", "Conditional", "Common", "VisualShaderNodeIs", TTR("Returns the boolean result of the comparison between INF (or NaN) and a scalar parameter."), -1, VisualShaderNode::PORT_TYPE_BOOLEAN));
-
-	add_options.push_back(AddOption("BooleanConstant", "Conditional", "Variables", "VisualShaderNodeBooleanConstant", TTR("Boolean constant."), -1, VisualShaderNode::PORT_TYPE_BOOLEAN));
-	add_options.push_back(AddOption("BooleanUniform", "Conditional", "Variables", "VisualShaderNodeBooleanUniform", TTR("Boolean uniform."), -1, VisualShaderNode::PORT_TYPE_BOOLEAN));
-
-	// INPUT
-
-	// SPATIAL-FOR-ALL
-	const String input_param_shader_modes = TTR("'%s' input parameter for all shader modes.");
-	add_options.push_back(AddOption("Camera", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "camera"), "camera", VisualShaderNode::PORT_TYPE_TRANSFORM, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("InvCamera", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "inv_camera"), "inv_camera", VisualShaderNode::PORT_TYPE_TRANSFORM, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("InvProjection", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "inv_projection"), "inv_projection", VisualShaderNode::PORT_TYPE_TRANSFORM, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Normal", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "normal"), "normal", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("OutputIsSRGB", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "output_is_srgb"), "output_is_srgb", VisualShaderNode::PORT_TYPE_BOOLEAN, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Projection", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "camera"), "projection", VisualShaderNode::PORT_TYPE_TRANSFORM, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Time", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "time"), "time", VisualShaderNode::PORT_TYPE_SCALAR, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("ViewportSize", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "viewport_size"), "viewport_size", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("World", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "world"), "world", VisualShaderNode::PORT_TYPE_TRANSFORM, -1, Shader::MODE_SPATIAL));
-
-	// CANVASITEM-FOR-ALL
-
-	add_options.push_back(AddOption("Alpha", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "alpha"), "alpha", VisualShaderNode::PORT_TYPE_SCALAR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Color", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "color"), "color", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ModulateAlpha", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "modulate_alpha"), "modulate_alpha", VisualShaderNode::PORT_TYPE_SCALAR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ModulateColor", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "modulate_color"), "modulate_color", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("TexturePixelSize", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "texture_pixel_size"), "texture_pixel_size", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Time", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "time"), "time", VisualShaderNode::PORT_TYPE_SCALAR, -1, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("UV", "Input", "All", "VisualShaderNodeInput", vformat(input_param_shader_modes, "uv"), "uv", VisualShaderNode::PORT_TYPE_VECTOR, -1, Shader::MODE_CANVAS_ITEM));
-
-	/////////////////
-
-	add_options.push_back(AddOption("Input", "Input", "Common", "VisualShaderNodeInput", TTR("Input parameter.")));
-
-	// SPATIAL INPUTS
-
-	const String input_param_for_vertex_and_fragment_shader_modes = TTR("'%s' input parameter for vertex and fragment shader modes.");
-	const String input_param_for_fragment_and_light_shader_modes = TTR("'%s' input parameter for fragment and light shader modes.");
-	const String input_param_for_fragment_shader_mode = TTR("'%s' input parameter for fragment shader mode.");
-	const String input_param_for_light_shader_mode = TTR("'%s' input parameter for light shader mode.");
-	const String input_param_for_vertex_shader_mode = TTR("'%s' input parameter for vertex shader mode.");
-	const String input_param_for_vertex_and_fragment_shader_mode = TTR("'%s' input parameter for vertex and fragment shader mode.");
-
-	add_options.push_back(AddOption("Alpha", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "alpha"), "alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Binormal", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "binormal"), "binormal", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Color", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "color"), "color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("DepthTexture", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "depth_texture"), "depth_texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("FragCoord", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "fragcoord"), "fragcoord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("FrontFacing", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "front_facing"), "front_facing", VisualShaderNode::PORT_TYPE_BOOLEAN, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("PointCoord", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "point_coord"), "point_coord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("ScreenTexture", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_texture"), "screen_texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("ScreenUV", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_uv"), "screen_uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Side", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "side"), "side", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Tangent", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "tangent"), "tangent", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("UV", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "uv"), "uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("UV2", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "uv2"), "uv2", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Vertex", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "vertex"), "vertex", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("View", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "view"), "view", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_SPATIAL));
-
-	add_options.push_back(AddOption("Albedo", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "albedo"), "albedo", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Attenuation", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "attenuation"), "attenuation", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Diffuse", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "diffuse"), "diffuse", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("FragCoord", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "fragcoord"), "fragcoord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Light", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light"), "light", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("LightColor", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_color"), "light_color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Metallic", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "metallic"), "metallic", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Roughness", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "roughness"), "roughness", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Specular", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "specular"), "specular", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Transmission", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "transmission"), "transmission", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("View", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "view"), "view", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-
-	add_options.push_back(AddOption("Alpha", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "alpha"), "alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Binormal", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "binormal"), "binormal", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Color", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "color"), "color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("ModelView", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "modelview"), "modelview", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("PointSize", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "point_size"), "point_size", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Tangent", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_mode, "tangent"), "tangent", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("UV", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "uv"), "uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("UV2", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "uv2"), "uv2", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-	add_options.push_back(AddOption("Vertex", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "vertex"), "vertex", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_SPATIAL));
-
-	// CANVASITEM INPUTS
-
-	add_options.push_back(AddOption("FragCoord", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "fragcoord"), "fragcoord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightPass", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "light_pass"), "light_pass", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("NormalTexture", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "normal_texture"), "normal_texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("PointCoord", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "point_coord"), "point_coord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ScreenPixelSize", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_pixel_size"), "screen_pixel_size", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ScreenTexture", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_texture"), "screen_texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ScreenUV", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "screen_uv"), "screen_uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Texture", "Input", "Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "texture"), "texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_FRAGMENT, Shader::MODE_CANVAS_ITEM));
-
-	add_options.push_back(AddOption("FragCoord", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "fragcoord"), "fragcoord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightAlpha", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_alpha"), "light_alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightColor", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_color"), "light_color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightHeight", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_height"), "light_height", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightUV", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_uv"), "light_uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightVector", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "light_vec"), "light_vec", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Normal", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "normal"), "normal", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("PointCoord", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "point_coord"), "point_coord", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ScreenUV", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "screen_uv"), "screen_uv", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ShadowAlpha", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "shadow_alpha"), "shadow_alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ShadowColor", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "shadow_color"), "shadow_color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("ShadowVec", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_light_shader_mode, "shadow_vec"), "shadow_vec", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Texture", "Input", "Light", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "texture"), "texture", VisualShaderNode::PORT_TYPE_SAMPLER, VisualShader::TYPE_LIGHT, Shader::MODE_CANVAS_ITEM));
-
-	add_options.push_back(AddOption("Extra", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "extra"), "extra", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("LightPass", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "light_pass"), "light_pass", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("PointSize", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "point_size"), "point_size", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Projection", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "projection"), "projection", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("Vertex", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "vertex"), "vertex", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-	add_options.push_back(AddOption("World", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "world"), "world", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_CANVAS_ITEM));
-
-	// PARTICLES INPUTS
-
-	add_options.push_back(AddOption("Active", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "active"), "active", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Alpha", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "alpha"), "alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Color", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "color"), "color", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Custom", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "custom"), "custom", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("CustomAlpha", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "custom_alpha"), "custom_alpha", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Delta", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "delta"), "delta", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("EmissionTransform", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "emission_transform"), "emission_transform", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Index", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "index"), "index", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("LifeTime", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "lifetime"), "lifetime", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Restart", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "restart"), "restart", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Time", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "time"), "time", VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Transform", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "transform"), "transform", VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-	add_options.push_back(AddOption("Velocity", "Input", "Vertex", "VisualShaderNodeInput", vformat(input_param_for_vertex_shader_mode, "velocity"), "velocity", VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_VERTEX, Shader::MODE_PARTICLES));
-
-	// SCALAR
-
-	add_options.push_back(AddOption("ScalarFunc", "Scalar", "Common", "VisualShaderNodeScalarFunc", TTR("Scalar function."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ScalarOp", "Scalar", "Common", "VisualShaderNodeScalarOp", TTR("Scalar operator."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-
-	//CONSTANTS
-
-	add_options.push_back(AddOption("E", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("E constant (2.718282). Represents the base of the natural logarithm."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_E));
-	add_options.push_back(AddOption("Epsilon", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Epsilon constant (0.00001). Smallest possible scalar number."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, CMP_EPSILON));
-	add_options.push_back(AddOption("Phi", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Phi constant (1.618034). Golden ratio."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, 1.618034f));
-	add_options.push_back(AddOption("Pi/4", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Pi/4 constant (0.785398) or 45 degrees."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_PI / 4));
-	add_options.push_back(AddOption("Pi/2", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Pi/2 constant (1.570796) or 90 degrees."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_PI / 2));
-	add_options.push_back(AddOption("Pi", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Pi constant (3.141593) or 180 degrees."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_PI));
-	add_options.push_back(AddOption("Tau", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Tau constant (6.283185) or 360 degrees."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_TAU));
-	add_options.push_back(AddOption("Sqrt2", "Scalar", "Constants", "VisualShaderNodeScalarConstant", TTR("Sqrt2 constant (1.414214). Square root of 2."), -1, VisualShaderNode::PORT_TYPE_SCALAR, -1, -1, Math_SQRT2));
-
-	// FUNCTIONS
-
-	add_options.push_back(AddOption("Abs", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the absolute value of the parameter."), VisualShaderNodeScalarFunc::FUNC_ABS, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ACos", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the arc-cosine of the parameter."), VisualShaderNodeScalarFunc::FUNC_ACOS, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ACosH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the inverse hyperbolic cosine of the parameter."), VisualShaderNodeScalarFunc::FUNC_ACOSH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ASin", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the arc-sine of the parameter."), VisualShaderNodeScalarFunc::FUNC_ASIN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ASinH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the inverse hyperbolic sine of the parameter."), VisualShaderNodeScalarFunc::FUNC_ASINH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ATan", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the arc-tangent of the parameter."), VisualShaderNodeScalarFunc::FUNC_ATAN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ATan2", "Scalar", "Functions", "VisualShaderNodeScalarOp", TTR("Returns the arc-tangent of the parameters."), VisualShaderNodeScalarOp::OP_ATAN2, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ATanH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the inverse hyperbolic tangent of the parameter."), VisualShaderNodeScalarFunc::FUNC_ATANH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Ceil", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Finds the nearest integer that is greater than or equal to the parameter."), VisualShaderNodeScalarFunc::FUNC_CEIL, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Clamp", "Scalar", "Functions", "VisualShaderNodeScalarClamp", TTR("Constrains a value to lie between two further values."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Cos", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the cosine of the parameter."), VisualShaderNodeScalarFunc::FUNC_COS, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("CosH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the hyperbolic cosine of the parameter."), VisualShaderNodeScalarFunc::FUNC_COSH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Degrees", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Converts a quantity in radians to degrees."), VisualShaderNodeScalarFunc::FUNC_DEGREES, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Exp", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Base-e Exponential."), VisualShaderNodeScalarFunc::FUNC_EXP, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Exp2", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Base-2 Exponential."), VisualShaderNodeScalarFunc::FUNC_EXP2, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Floor", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Finds the nearest integer less than or equal to the parameter."), VisualShaderNodeScalarFunc::FUNC_FLOOR, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Fract", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Computes the fractional part of the argument."), VisualShaderNodeScalarFunc::FUNC_FRAC, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("InverseSqrt", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the inverse of the square root of the parameter."), VisualShaderNodeScalarFunc::FUNC_INVERSE_SQRT, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Log", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Natural logarithm."), VisualShaderNodeScalarFunc::FUNC_LOG, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Log2", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Base-2 logarithm."), VisualShaderNodeScalarFunc::FUNC_LOG2, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Max", "Scalar", "Functions", "VisualShaderNodeScalarOp", TTR("Returns the greater of two values."), VisualShaderNodeScalarOp::OP_MAX, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Min", "Scalar", "Functions", "VisualShaderNodeScalarOp", TTR("Returns the lesser of two values."), VisualShaderNodeScalarOp::OP_MIN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Mix", "Scalar", "Functions", "VisualShaderNodeScalarInterp", TTR("Linear interpolation between two scalars."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Negate", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the opposite value of the parameter."), VisualShaderNodeScalarFunc::FUNC_NEGATE, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("OneMinus", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("1.0 - scalar"), VisualShaderNodeScalarFunc::FUNC_ONEMINUS, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Pow", "Scalar", "Functions", "VisualShaderNodeScalarOp", TTR("Returns the value of the first parameter raised to the power of the second."), VisualShaderNodeScalarOp::OP_POW, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Radians", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Converts a quantity in degrees to radians."), VisualShaderNodeScalarFunc::FUNC_RADIANS, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Reciprocal", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("1.0 / scalar"), VisualShaderNodeScalarFunc::FUNC_RECIPROCAL, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Round", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Finds the nearest integer to the parameter."), VisualShaderNodeScalarFunc::FUNC_ROUND, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("RoundEven", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Finds the nearest even integer to the parameter."), VisualShaderNodeScalarFunc::FUNC_ROUNDEVEN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Saturate", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Clamps the value between 0.0 and 1.0."), VisualShaderNodeScalarFunc::FUNC_SATURATE, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Sign", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Extracts the sign of the parameter."), VisualShaderNodeScalarFunc::FUNC_SIGN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Sin", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the sine of the parameter."), VisualShaderNodeScalarFunc::FUNC_SIN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("SinH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the hyperbolic sine of the parameter."), VisualShaderNodeScalarFunc::FUNC_SINH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Sqrt", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the square root of the parameter."), VisualShaderNodeScalarFunc::FUNC_SQRT, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("SmoothStep", "Scalar", "Functions", "VisualShaderNodeScalarSmoothStep", TTR("SmoothStep function( scalar(edge0), scalar(edge1), scalar(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge0' and 1.0 if x is larger than 'edge1'. Otherwise the return value is interpolated between 0.0 and 1.0 using Hermite polynomials."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Step", "Scalar", "Functions", "VisualShaderNodeScalarOp", TTR("Step function( scalar(edge), scalar(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge' and otherwise 1.0."), VisualShaderNodeScalarOp::OP_STEP, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Tan", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the tangent of the parameter."), VisualShaderNodeScalarFunc::FUNC_TAN, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("TanH", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Returns the hyperbolic tangent of the parameter."), VisualShaderNodeScalarFunc::FUNC_TANH, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Trunc", "Scalar", "Functions", "VisualShaderNodeScalarFunc", TTR("Finds the truncated value of the parameter."), VisualShaderNodeScalarFunc::FUNC_TRUNC, VisualShaderNode::PORT_TYPE_SCALAR));
-
-	add_options.push_back(AddOption("Add", "Scalar", "Operators", "VisualShaderNodeScalarOp", TTR("Adds scalar to scalar."), VisualShaderNodeScalarOp::OP_ADD, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Divide", "Scalar", "Operators", "VisualShaderNodeScalarOp", TTR("Divides scalar by scalar."), VisualShaderNodeScalarOp::OP_DIV, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Multiply", "Scalar", "Operators", "VisualShaderNodeScalarOp", TTR("Multiplies scalar by scalar."), VisualShaderNodeScalarOp::OP_MUL, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Remainder", "Scalar", "Operators", "VisualShaderNodeScalarOp", TTR("Returns the remainder of the two scalars."), VisualShaderNodeScalarOp::OP_MOD, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Subtract", "Scalar", "Operators", "VisualShaderNodeScalarOp", TTR("Subtracts scalar from scalar."), VisualShaderNodeScalarOp::OP_SUB, VisualShaderNode::PORT_TYPE_SCALAR));
-
-	add_options.push_back(AddOption("ScalarConstant", "Scalar", "Variables", "VisualShaderNodeScalarConstant", TTR("Scalar constant."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("ScalarUniform", "Scalar", "Variables", "VisualShaderNodeScalarUniform", TTR("Scalar uniform."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-
-	// TEXTURES
-
-	add_options.push_back(AddOption("CubeMap", "Textures", "Functions", "VisualShaderNodeCubeMap", TTR("Perform the cubic texture lookup."), -1, -1));
-	texture_node_option_idx = add_options.size();
-	add_options.push_back(AddOption("Texture", "Textures", "Functions", "VisualShaderNodeTexture", TTR("Perform the texture lookup."), -1, -1));
-
-	add_options.push_back(AddOption("CubeMapUniform", "Textures", "Variables", "VisualShaderNodeCubeMapUniform", TTR("Cubic texture uniform lookup."), -1, -1));
-	add_options.push_back(AddOption("TextureUniform", "Textures", "Variables", "VisualShaderNodeTextureUniform", TTR("2D texture uniform lookup."), -1, -1));
-	add_options.push_back(AddOption("TextureUniformTriplanar", "Textures", "Variables", "VisualShaderNodeTextureUniformTriplanar", TTR("2D texture uniform lookup with triplanar."), -1, -1, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, Shader::MODE_SPATIAL));
-
-	// TRANSFORM
-
-	add_options.push_back(AddOption("TransformFunc", "Transform", "Common", "VisualShaderNodeTransformFunc", TTR("Transform function."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-
-	add_options.push_back(AddOption("OuterProduct", "Transform", "Composition", "VisualShaderNodeOuterProduct", TTR("Calculate the outer product of a pair of vectors.\n\nOuterProduct treats the first parameter 'c' as a column vector (matrix with one column) and the second parameter 'r' as a row vector (matrix with one row) and does a linear algebraic matrix multiply 'c * r', yielding a matrix whose number of rows is the number of components in 'c' and whose number of columns is the number of components in 'r'."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-	add_options.push_back(AddOption("TransformCompose", "Transform", "Composition", "VisualShaderNodeTransformCompose", TTR("Composes transform from four vectors."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-	add_options.push_back(AddOption("TransformDecompose", "Transform", "Composition", "VisualShaderNodeTransformDecompose", TTR("Decomposes transform to four vectors.")));
-
-	add_options.push_back(AddOption("Determinant", "Transform", "Functions", "VisualShaderNodeDeterminant", TTR("Calculates the determinant of a transform."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Inverse", "Transform", "Functions", "VisualShaderNodeTransformFunc", TTR("Calculates the inverse of a transform."), VisualShaderNodeTransformFunc::FUNC_INVERSE, VisualShaderNode::PORT_TYPE_TRANSFORM));
-	add_options.push_back(AddOption("Transpose", "Transform", "Functions", "VisualShaderNodeTransformFunc", TTR("Calculates the transpose of a transform."), VisualShaderNodeTransformFunc::FUNC_TRANSPOSE, VisualShaderNode::PORT_TYPE_TRANSFORM));
-
-	add_options.push_back(AddOption("TransformMult", "Transform", "Operators", "VisualShaderNodeTransformMult", TTR("Multiplies transform by transform."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-	add_options.push_back(AddOption("TransformVectorMult", "Transform", "Operators", "VisualShaderNodeTransformVecMult", TTR("Multiplies vector by transform."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("TransformConstant", "Transform", "Variables", "VisualShaderNodeTransformConstant", TTR("Transform constant."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-	add_options.push_back(AddOption("TransformUniform", "Transform", "Variables", "VisualShaderNodeTransformUniform", TTR("Transform uniform."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
-
-	// VECTOR
-
-	add_options.push_back(AddOption("VectorFunc", "Vector", "Common", "VisualShaderNodeVectorFunc", TTR("Vector function."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("VectorOp", "Vector", "Common", "VisualShaderNodeVectorOp", TTR("Vector operator."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("VectorCompose", "Vector", "Composition", "VisualShaderNodeVectorCompose", TTR("Composes vector from three scalars."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("VectorDecompose", "Vector", "Composition", "VisualShaderNodeVectorDecompose", TTR("Decomposes vector to three scalars.")));
-
-	add_options.push_back(AddOption("Abs", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the absolute value of the parameter."), VisualShaderNodeVectorFunc::FUNC_ABS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ACos", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the arc-cosine of the parameter."), VisualShaderNodeVectorFunc::FUNC_ACOS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ACosH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the inverse hyperbolic cosine of the parameter."), VisualShaderNodeVectorFunc::FUNC_ACOSH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ASin", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the arc-sine of the parameter."), VisualShaderNodeVectorFunc::FUNC_ASIN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ASinH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the inverse hyperbolic sine of the parameter."), VisualShaderNodeVectorFunc::FUNC_ASINH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ATan", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the arc-tangent of the parameter."), VisualShaderNodeVectorFunc::FUNC_ATAN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ATan2", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Returns the arc-tangent of the parameters."), VisualShaderNodeVectorOp::OP_ATAN2, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("ATanH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the inverse hyperbolic tangent of the parameter."), VisualShaderNodeVectorFunc::FUNC_ATANH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Ceil", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Finds the nearest integer that is greater than or equal to the parameter."), VisualShaderNodeVectorFunc::FUNC_CEIL, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Clamp", "Vector", "Functions", "VisualShaderNodeVectorClamp", TTR("Constrains a value to lie between two further values."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Cos", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the cosine of the parameter."), VisualShaderNodeVectorFunc::FUNC_COS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("CosH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the hyperbolic cosine of the parameter."), VisualShaderNodeVectorFunc::FUNC_COSH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Cross", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Calculates the cross product of two vectors."), VisualShaderNodeVectorOp::OP_CROSS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Degrees", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Converts a quantity in radians to degrees."), VisualShaderNodeVectorFunc::FUNC_DEGREES, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Distance", "Vector", "Functions", "VisualShaderNodeVectorDistance", TTR("Returns the distance between two points."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Dot", "Vector", "Functions", "VisualShaderNodeDotProduct", TTR("Calculates the dot product of two vectors."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Exp", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Base-e Exponential."), VisualShaderNodeVectorFunc::FUNC_EXP, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Exp2", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Base-2 Exponential."), VisualShaderNodeVectorFunc::FUNC_EXP2, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("FaceForward", "Vector", "Functions", "VisualShaderNodeFaceForward", TTR("Returns the vector that points in the same direction as a reference vector. The function has three vector parameters : N, the vector to orient, I, the incident vector, and Nref, the reference vector. If the dot product of I and Nref is smaller than zero the return value is N. Otherwise -N is returned."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Floor", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Finds the nearest integer less than or equal to the parameter."), VisualShaderNodeVectorFunc::FUNC_FLOOR, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Fract", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Computes the fractional part of the argument."), VisualShaderNodeVectorFunc::FUNC_FRAC, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("InverseSqrt", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the inverse of the square root of the parameter."), VisualShaderNodeVectorFunc::FUNC_INVERSE_SQRT, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Length", "Vector", "Functions", "VisualShaderNodeVectorLen", TTR("Calculates the length of a vector."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("Log", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Natural logarithm."), VisualShaderNodeVectorFunc::FUNC_LOG, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Log2", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Base-2 logarithm."), VisualShaderNodeVectorFunc::FUNC_LOG2, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Max", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Returns the greater of two values."), VisualShaderNodeVectorOp::OP_MAX, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Min", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Returns the lesser of two values."), VisualShaderNodeVectorOp::OP_MIN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Mix", "Vector", "Functions", "VisualShaderNodeVectorInterp", TTR("Linear interpolation between two vectors."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("MixS", "Vector", "Functions", "VisualShaderNodeVectorScalarMix", TTR("Linear interpolation between two vectors using scalar."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Negate", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the opposite value of the parameter."), VisualShaderNodeVectorFunc::FUNC_NEGATE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Normalize", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Calculates the normalize product of vector."), VisualShaderNodeVectorFunc::FUNC_NORMALIZE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("OneMinus", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("1.0 - vector"), VisualShaderNodeVectorFunc::FUNC_ONEMINUS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Pow", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Returns the value of the first parameter raised to the power of the second."), VisualShaderNodeVectorOp::OP_POW, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Radians", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Converts a quantity in degrees to radians."), VisualShaderNodeVectorFunc::FUNC_RADIANS, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Reciprocal", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("1.0 / vector"), VisualShaderNodeVectorFunc::FUNC_RECIPROCAL, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Reflect", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Returns the vector that points in the direction of reflection ( a : incident vector, b : normal vector )."), VisualShaderNodeVectorOp::OP_REFLECT, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Refract", "Vector", "Functions", "VisualShaderNodeVectorRefract", TTR("Returns the vector that points in the direction of refraction."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Round", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Finds the nearest integer to the parameter."), VisualShaderNodeVectorFunc::FUNC_ROUND, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("RoundEven", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Finds the nearest even integer to the parameter."), VisualShaderNodeVectorFunc::FUNC_ROUNDEVEN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Saturate", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Clamps the value between 0.0 and 1.0."), VisualShaderNodeVectorFunc::FUNC_SATURATE, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Sign", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Extracts the sign of the parameter."), VisualShaderNodeVectorFunc::FUNC_SIGN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Sin", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the sine of the parameter."), VisualShaderNodeVectorFunc::FUNC_SIN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("SinH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the hyperbolic sine of the parameter."), VisualShaderNodeVectorFunc::FUNC_SINH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Sqrt", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the square root of the parameter."), VisualShaderNodeVectorFunc::FUNC_SQRT, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("SmoothStep", "Vector", "Functions", "VisualShaderNodeVectorSmoothStep", TTR("SmoothStep function( vector(edge0), vector(edge1), vector(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge0' and 1.0 if 'x' is larger than 'edge1'. Otherwise the return value is interpolated between 0.0 and 1.0 using Hermite polynomials."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("SmoothStepS", "Vector", "Functions", "VisualShaderNodeVectorScalarSmoothStep", TTR("SmoothStep function( scalar(edge0), scalar(edge1), vector(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge0' and 1.0 if 'x' is larger than 'edge1'. Otherwise the return value is interpolated between 0.0 and 1.0 using Hermite polynomials."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Step", "Vector", "Functions", "VisualShaderNodeVectorOp", TTR("Step function( vector(edge), vector(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge' and otherwise 1.0."), VisualShaderNodeVectorOp::OP_STEP, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("StepS", "Vector", "Functions", "VisualShaderNodeVectorScalarStep", TTR("Step function( scalar(edge), vector(x) ).\n\nReturns 0.0 if 'x' is smaller than 'edge' and otherwise 1.0."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Tan", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the tangent of the parameter."), VisualShaderNodeVectorFunc::FUNC_TAN, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("TanH", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Returns the hyperbolic tangent of the parameter."), VisualShaderNodeVectorFunc::FUNC_TANH, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Trunc", "Vector", "Functions", "VisualShaderNodeVectorFunc", TTR("Finds the truncated value of the parameter."), VisualShaderNodeVectorFunc::FUNC_TRUNC, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("Add", "Vector", "Operators", "VisualShaderNodeVectorOp", TTR("Adds vector to vector."), VisualShaderNodeVectorOp::OP_ADD, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Divide", "Vector", "Operators", "VisualShaderNodeVectorOp", TTR("Divides vector by vector."), VisualShaderNodeVectorOp::OP_DIV, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Multiply", "Vector", "Operators", "VisualShaderNodeVectorOp", TTR("Multiplies vector by vector."), VisualShaderNodeVectorOp::OP_MUL, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Remainder", "Vector", "Operators", "VisualShaderNodeVectorOp", TTR("Returns the remainder of the two vectors."), VisualShaderNodeVectorOp::OP_MOD, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("Subtract", "Vector", "Operators", "VisualShaderNodeVectorOp", TTR("Subtracts vector from vector."), VisualShaderNodeVectorOp::OP_SUB, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	add_options.push_back(AddOption("VectorConstant", "Vector", "Variables", "VisualShaderNodeVec3Constant", TTR("Vector constant."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-	add_options.push_back(AddOption("VectorUniform", "Vector", "Variables", "VisualShaderNodeVec3Uniform", TTR("Vector uniform."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
-
-	// SPECIAL
-
-	add_options.push_back(AddOption("Expression", "Special", "", "VisualShaderNodeExpression", TTR("Custom Godot Shader Language expression, with custom amount of input and output ports. This is a direct injection of code into the vertex/fragment/light function, do not use it to write the function declarations inside.")));
-	add_options.push_back(AddOption("Fresnel", "Special", "", "VisualShaderNodeFresnel", TTR("Returns falloff based on the dot product of surface normal and view direction of camera (pass associated inputs to it)."), -1, VisualShaderNode::PORT_TYPE_SCALAR));
-	add_options.push_back(AddOption("GlobalExpression", "Special", "", "VisualShaderNodeGlobalExpression", TTR("Custom Godot Shader Language expression, which is placed on top of the resulted shader. You can place various function definitions inside and call it later in the Expressions. You can also declare varyings, uniforms and constants.")));
-	add_options.push_back(AddOption("UniformRef", "Special", "", "VisualShaderNodeUniformRef", TTR("A reference to an existing uniform.")));
-
-	add_options.push_back(AddOption("ScalarDerivativeFunc", "Special", "Common", "VisualShaderNodeScalarDerivativeFunc", TTR("(Fragment/Light mode only) Scalar derivative function."), -1, VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("VectorDerivativeFunc", "Special", "Common", "VisualShaderNodeVectorDerivativeFunc", TTR("(Fragment/Light mode only) Vector derivative function."), -1, VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-
-	add_options.push_back(AddOption("DdX", "Special", "Derivative", "VisualShaderNodeVectorDerivativeFunc", TTR("(Fragment/Light mode only) (Vector) Derivative in 'x' using local differencing."), VisualShaderNodeVectorDerivativeFunc::FUNC_X, VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("DdXS", "Special", "Derivative", "VisualShaderNodeScalarDerivativeFunc", TTR("(Fragment/Light mode only) (Scalar) Derivative in 'x' using local differencing."), VisualShaderNodeScalarDerivativeFunc::FUNC_X, VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("DdY", "Special", "Derivative", "VisualShaderNodeVectorDerivativeFunc", TTR("(Fragment/Light mode only) (Vector) Derivative in 'y' using local differencing."), VisualShaderNodeVectorDerivativeFunc::FUNC_Y, VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("DdYS", "Special", "Derivative", "VisualShaderNodeScalarDerivativeFunc", TTR("(Fragment/Light mode only) (Scalar) Derivative in 'y' using local differencing."), VisualShaderNodeScalarDerivativeFunc::FUNC_Y, VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("Sum", "Special", "Derivative", "VisualShaderNodeVectorDerivativeFunc", TTR("(Fragment/Light mode only) (Vector) Sum of absolute derivative in 'x' and 'y'."), VisualShaderNodeVectorDerivativeFunc::FUNC_SUM, VisualShaderNode::PORT_TYPE_VECTOR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	add_options.push_back(AddOption("SumS", "Special", "Derivative", "VisualShaderNodeScalarDerivativeFunc", TTR("(Fragment/Light mode only) (Scalar) Sum of absolute derivative in 'x' and 'y'."), VisualShaderNodeScalarDerivativeFunc::FUNC_SUM, VisualShaderNode::PORT_TYPE_SCALAR, VisualShader::TYPE_FRAGMENT | VisualShader::TYPE_LIGHT, -1, -1, true));
-	custom_node_option_idx = add_options.size();
-
-	/////////////////////////////////////////////////////////////////////
-
-	_update_options_menu();
-
-	error_panel = memnew(PanelContainer);
-	add_child(error_panel);
-	error_label = memnew(Label);
-	error_panel->add_child(error_label);
-	error_label->set_text("eh");
-	error_panel->hide();
-
-	undo_redo = EditorNode::get_singleton()->get_undo_redo();
-
-	Ref<VisualShaderNodePluginDefault> default_plugin;
-	default_plugin.instance();
-	add_plugin(default_plugin);
-
-	property_editor = memnew(CustomPropertyEditor);
-	add_child(property_editor);
-
-	property_editor->connect("variant_changed", this, "_port_edited");
-}
-
-void VisualShaderEditorPlugin::edit(Object *p_object) {
-	visual_shader_editor->edit(Object::cast_to<VisualShader>(p_object));
-}
-
-bool VisualShaderEditorPlugin::handles(Object *p_object) const {
-	return p_object->is_class("VisualShader");
-}
-
-void VisualShaderEditorPlugin::make_visible(bool p_visible) {
-	if (p_visible) {
-		//editor->hide_animation_player_editors();
-		//editor->animation_panel_make_visible(true);
-		button->show();
-		editor->make_bottom_panel_item_visible(visual_shader_editor);
-		visual_shader_editor->update_custom_nodes();
-		visual_shader_editor->set_process_input(true);
-		//visual_shader_editor->set_process(true);
-	} else {
-		if (visual_shader_editor->is_visible_in_tree()) {
-			editor->hide_bottom_panel();
-		}
-		button->hide();
-		visual_shader_editor->set_process_input(false);
-		//visual_shader_editor->set_process(false);
-	}
-}
-
-VisualShaderEditorPlugin::VisualShaderEditorPlugin(EditorNode *p_node) {
-	editor = p_node;
-	visual_shader_editor = memnew(VisualShaderEditor);
-	visual_shader_editor->set_custom_minimum_size(Size2(0, 300) * EDSCALE);
-
-	button = editor->add_bottom_panel_item(TTR("VisualShader"), visual_shader_editor);
-	button->hide();
-}
-
-VisualShaderEditorPlugin::~VisualShaderEditorPlugin() {
-}
-
-////////////////
-
-class VisualShaderNodePluginInputEditor : public OptionButton {
-	GDCLASS(VisualShaderNodePluginInputEditor, OptionButton);
-
-	Ref<VisualShaderNodeInput> input;
-
-protected:
-	static void _bind_methods() {
-		ClassDB::bind_method("_item_selected", &VisualShaderNodePluginInputEditor::_item_selected);
-	}
-
-public:
-	void _notification(int p_what) {
-		if (p_what == NOTIFICATION_READY) {
-			connect("item_selected", this, "_item_selected");
-		}
-	}
-
-	void _item_selected(int p_item) {
-		VisualShaderEditor::get_singleton()->call_deferred("_input_select_item", input, get_item_text(p_item));
-	}
-
-	void setup(const Ref<VisualShaderNodeInput> &p_input) {
-		input = p_input;
-		Ref<Texture> type_icon[5] = {
-			EditorNode::get_singleton()->get_gui_base()->get_icon("float", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("Vector3", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("bool", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("Transform", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("ImageTexture", "EditorIcons"),
-		};
-
-		add_item("[None]");
-		int to_select = -1;
-		for (int i = 0; i < input->get_input_index_count(); i++) {
-			if (input->get_input_name() == input->get_input_index_name(i)) {
-				to_select = i + 1;
-			}
-			add_icon_item(type_icon[input->get_input_index_type(i)], input->get_input_index_name(i));
-		}
-
-		if (to_select >= 0) {
-			select(to_select);
-		}
-	}
-};
-
-////////////////
-
-class VisualShaderNodePluginUniformRefEditor : public OptionButton {
-	GDCLASS(VisualShaderNodePluginUniformRefEditor, OptionButton);
-
-	Ref<VisualShaderNodeUniformRef> uniform_ref;
-
-protected:
-	static void _bind_methods() {
-		ClassDB::bind_method("_item_selected", &VisualShaderNodePluginUniformRefEditor::_item_selected);
-	}
-
-public:
-	void _notification(int p_what) {
-		if (p_what == NOTIFICATION_READY) {
-			connect("item_selected", this, "_item_selected");
-		}
-	}
-
-	void _item_selected(int p_item) {
-		VisualShaderEditor::get_singleton()->call_deferred("_uniform_select_item", uniform_ref, get_item_text(p_item));
-	}
-
-	void setup(const Ref<VisualShaderNodeUniformRef> &p_uniform_ref) {
-		uniform_ref = p_uniform_ref;
-
-		Ref<Texture> type_icon[6] = {
-			EditorNode::get_singleton()->get_gui_base()->get_icon("float", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("bool", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("Vector3", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("Transform", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("Color", "EditorIcons"),
-			EditorNode::get_singleton()->get_gui_base()->get_icon("ImageTexture", "EditorIcons"),
-		};
-
-		add_item("[None]");
-		int to_select = -1;
-		for (int i = 0; i < p_uniform_ref->get_uniforms_count(); i++) {
-			if (p_uniform_ref->get_uniform_name() == p_uniform_ref->get_uniform_name_by_index(i)) {
-				to_select = i + 1;
-			}
-			add_icon_item(type_icon[p_uniform_ref->get_uniform_type_by_index(i)], p_uniform_ref->get_uniform_name_by_index(i));
-		}
-
-		if (to_select >= 0) {
-			select(to_select);
-		}
-	}
-};
-
-////////////////
-
-class VisualShaderNodePluginDefaultEditor : public VBoxContainer {
-	GDCLASS(VisualShaderNodePluginDefaultEditor, VBoxContainer);
-	Ref<Resource> parent_resource;
-
-public:
-	void _property_changed(const String &prop, const Variant &p_value, const String &p_field, bool p_changing = false) {
-		if (p_changing) {
-			return;
-		}
-
-		UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
-
-		updating = true;
-		undo_redo->create_action(TTR("Edit Visual Property:") + " " + prop, UndoRedo::MERGE_ENDS);
-		undo_redo->add_do_property(node.ptr(), prop, p_value);
-		undo_redo->add_undo_property(node.ptr(), prop, node->get(prop));
-
-		if (p_value.get_type() == Variant::OBJECT) {
-			RES prev_res = node->get(prop);
-			RES curr_res = p_value;
-
-			if (curr_res.is_null()) {
-				undo_redo->add_do_method(this, "_open_inspector", (RES)parent_resource.ptr());
-			} else {
-				undo_redo->add_do_method(this, "_open_inspector", (RES)curr_res.ptr());
-			}
-			if (!prev_res.is_null()) {
-				undo_redo->add_undo_method(this, "_open_inspector", (RES)prev_res.ptr());
-			} else {
-				undo_redo->add_undo_method(this, "_open_inspector", (RES)parent_resource.ptr());
-			}
-		}
-		undo_redo->add_do_method(this, "_refresh_request");
-		undo_redo->add_undo_method(this, "_refresh_request");
-		undo_redo->commit_action();
-
-		updating = false;
-	}
-
-	void _node_changed() {
-		if (updating) {
-			return;
-		}
-		for (int i = 0; i < properties.size(); i++) {
-			properties[i]->update_property();
-		}
-	}
-
-	void _refresh_request() {
-		VisualShaderEditor::get_singleton()->call_deferred("_update_graph");
-	}
-
-	void _resource_selected(const String &p_path, RES p_resource) {
-		_open_inspector(p_resource);
-	}
-
-	void _open_inspector(RES p_resource) {
-		EditorNode::get_singleton()->get_inspector()->edit(p_resource.ptr());
-	}
-
-	bool updating;
-	Ref<VisualShaderNode> node;
-	Vector<EditorProperty *> properties;
-
-	void setup(Ref<Resource> p_parent_resource, Vector<EditorProperty *> p_properties, const Vector<StringName> &p_names, Ref<VisualShaderNode> p_node) {
-		parent_resource = p_parent_resource;
-		updating = false;
-		node = p_node;
-		properties = p_properties;
-
-		for (int i = 0; i < p_properties.size(); i++) {
-			HBoxContainer *hbox = memnew(HBoxContainer);
-			hbox->set_h_size_flags(SIZE_EXPAND_FILL);
-			add_child(hbox);
-
-			if (p_node->is_show_prop_names()) {
-				Label *prop_name = memnew(Label);
-				prop_name->set_text(String(p_names[i]).capitalize() + ":");
-				hbox->add_child(prop_name);
-			}
-
-			p_properties[i]->set_h_size_flags(SIZE_EXPAND_FILL);
-			hbox->add_child(p_properties[i]);
-
-			bool res_prop = Object::cast_to<EditorPropertyResource>(p_properties[i]);
-			if (res_prop) {
-				p_properties[i]->connect("resource_selected", this, "_resource_selected");
-			}
-
-			properties[i]->connect("property_changed", this, "_property_changed");
-			properties[i]->set_object_and_property(node.ptr(), p_names[i]);
-			properties[i]->update_property();
-			properties[i]->set_name_split_ratio(0);
-		}
-		node->connect("changed", this, "_node_changed");
-		node->connect("editor_refresh_request", this, "_refresh_request", varray(), CONNECT_DEFERRED);
-	}
-
-	static void _bind_methods() {
-		ClassDB::bind_method("_property_changed", &VisualShaderNodePluginDefaultEditor::_property_changed, DEFVAL(String()), DEFVAL(false));
-		ClassDB::bind_method("_node_changed", &VisualShaderNodePluginDefaultEditor::_node_changed);
-		ClassDB::bind_method("_refresh_request", &VisualShaderNodePluginDefaultEditor::_refresh_request);
-		ClassDB::bind_method("_resource_selected", &VisualShaderNodePluginDefaultEditor::_resource_selected);
-		ClassDB::bind_method("_open_inspector", &VisualShaderNodePluginDefaultEditor::_open_inspector);
-	}
-};
-
-Control *VisualShaderNodePluginDefault::create_editor(const Ref<Resource> &p_parent_resource, const Ref<VisualShaderNode> &p_node) {
-	if (p_node->is_class("VisualShaderNodeUniformRef")) {
-		//create input
-		VisualShaderNodePluginUniformRefEditor *uniform_editor = memnew(VisualShaderNodePluginUniformRefEditor);
-		uniform_editor->setup(p_node);
-		return uniform_editor;
-	}
-
-	if (p_node->is_class("VisualShaderNodeInput")) {
-		//create input
-		VisualShaderNodePluginInputEditor *input_editor = memnew(VisualShaderNodePluginInputEditor);
-		input_editor->setup(p_node);
-		return input_editor;
-	}
-
-	Vector<StringName> properties = p_node->get_editable_properties();
-	if (properties.size() == 0) {
-		return nullptr;
-	}
-
-	List<PropertyInfo> props;
-	p_node->get_property_list(&props);
-
-	Vector<PropertyInfo> pinfo;
-
-	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
-		for (int i = 0; i < properties.size(); i++) {
-			if (E->get().name == String(properties[i])) {
-				pinfo.push_back(E->get());
-			}
-		}
-	}
-
-	if (pinfo.size() == 0) {
-		return nullptr;
-	}
-
-	properties.clear();
-
-	Ref<VisualShaderNode> node = p_node;
-	Vector<EditorProperty *> editors;
-
-	for (int i = 0; i < pinfo.size(); i++) {
-		EditorProperty *prop = EditorInspector::instantiate_property_editor(node.ptr(), pinfo[i].type, pinfo[i].name, pinfo[i].hint, pinfo[i].hint_string, pinfo[i].usage);
-		if (!prop) {
-			return nullptr;
-		}
-
-		if (Object::cast_to<EditorPropertyResource>(prop)) {
-			Object::cast_to<EditorPropertyResource>(prop)->set_use_sub_inspector(false);
-			prop->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
-		} else if (Object::cast_to<EditorPropertyTransform>(prop) || Object::cast_to<EditorPropertyVector3>(prop)) {
-			prop->set_custom_minimum_size(Size2(250 * EDSCALE, 0));
-		} else if (Object::cast_to<EditorPropertyFloat>(prop)) {
-			prop->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
-		} else if (Object::cast_to<EditorPropertyEnum>(prop)) {
-			prop->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
-			Object::cast_to<EditorPropertyEnum>(prop)->set_option_button_clip(false);
-		}
-
-		editors.push_back(prop);
-		properties.push_back(pinfo[i].name);
-	}
-	VisualShaderNodePluginDefaultEditor *editor = memnew(VisualShaderNodePluginDefaultEditor);
-	editor->setup(p_parent_resource, editors, properties, p_node);
-	return editor;
-}
-
-void EditorPropertyShaderMode::_option_selected(int p_which) {
-	//will not use this, instead will do all the logic setting manually
-	//emit_signal("property_changed", get_edited_property(), p_which);
-
-	Ref<VisualShader> visual_shader(Object::cast_to<VisualShader>(get_edited_object()));
-
-	if (visual_shader->get_mode() == p_which) {
-		return;
-	}
-
-	UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
-	undo_redo->create_action(TTR("Visual Shader Mode Changed"));
-	//do is easy
-	undo_redo->add_do_method(visual_shader.ptr(), "set_mode", p_which);
-	undo_redo->add_undo_method(visual_shader.ptr(), "set_mode", visual_shader->get_mode());
-	//now undo is hell
-
-	//1. restore connections to output
-	for (int i = 0; i < VisualShader::TYPE_MAX; i++) {
-		VisualShader::Type type = VisualShader::Type(i);
-		List<VisualShader::Connection> conns;
-		visual_shader->get_node_connections(type, &conns);
-		for (List<VisualShader::Connection>::Element *E = conns.front(); E; E = E->next()) {
-			if (E->get().to_node == VisualShader::NODE_ID_OUTPUT) {
-				undo_redo->add_undo_method(visual_shader.ptr(), "connect_nodes", type, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
-			}
-		}
-	}
-	//2. restore input indices
-	for (int i = 0; i < VisualShader::TYPE_MAX; i++) {
-		VisualShader::Type type = VisualShader::Type(i);
-		Vector<int> nodes = visual_shader->get_node_list(type);
-		for (int j = 0; j < nodes.size(); j++) {
-			Ref<VisualShaderNodeInput> input = visual_shader->get_node(type, nodes[j]);
-			if (!input.is_valid()) {
-				continue;
-			}
-
-			undo_redo->add_undo_method(input.ptr(), "set_input_name", input->get_input_name());
-		}
-	}
-
-	//3. restore enums and flags
-	List<PropertyInfo> props;
-	visual_shader->get_property_list(&props);
-
-	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
-		if (E->get().name.begins_with("flags/") || E->get().name.begins_with("modes/")) {
-			undo_redo->add_undo_property(visual_shader.ptr(), E->get().name, visual_shader->get(E->get().name));
-		}
-	}
-
-	undo_redo->add_do_method(VisualShaderEditor::get_singleton(), "_update_options_menu");
-	undo_redo->add_undo_method(VisualShaderEditor::get_singleton(), "_update_options_menu");
-
-	//update graph
-	undo_redo->add_do_method(VisualShaderEditor::get_singleton(), "_update_graph");
-	undo_redo->add_undo_method(VisualShaderEditor::get_singleton(), "_update_graph");
-
-	undo_redo->commit_action();
-}
-
-void EditorPropertyShaderMode::update_property() {
-	int which = get_edited_object()->get(get_edited_property());
-	options->select(which);
-}
-
-void EditorPropertyShaderMode::setup(const Vector<String> &p_options) {
-	for (int i = 0; i < p_options.size(); i++) {
-		options->add_item(p_options[i], i);
-	}
-}
-
-void EditorPropertyShaderMode::set_option_button_clip(bool p_enable) {
-	options->set_clip_text(p_enable);
-}
-
-void EditorPropertyShaderMode::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("_option_selected"), &EditorPropertyShaderMode::_option_selected);
-}
-
-EditorPropertyShaderMode::EditorPropertyShaderMode() {
-	options = memnew(OptionButton);
-	options->set_clip_text(true);
-	add_child(options);
-	add_focusable(options);
-	options->connect("item_selected", this, "_option_selected");
-}
-
-bool EditorInspectorShaderModePlugin::can_handle(Object *p_object) {
-	return true; //can handle everything
-}
-
-void EditorInspectorShaderModePlugin::parse_begin(Object *p_object) {
-	//do none
-}
-
-bool EditorInspectorShaderModePlugin::parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage) {
-	if (p_path == "mode" && p_object->is_class("VisualShader") && p_type == Variant::INT) {
-		EditorPropertyShaderMode *editor = memnew(EditorPropertyShaderMode);
-		Vector<String> options = p_hint_text.split(",");
-		editor->setup(options);
-		add_property_editor(p_path, editor);
-
-		return true;
-	}
-
-	return false; //can be overridden, although it will most likely be last anyway
-}
-
-void EditorInspectorShaderModePlugin::parse_end() {
-	//do none
-}
-//////////////////////////////////
-
-void VisualShaderNodePortPreview::_shader_changed() {
-	if (shader.is_null()) {
-		return;
-	}
-
-	Vector<VisualShader::DefaultTextureParam> default_textures;
-	String shader_code = shader->generate_preview_shader(type, node, port, default_textures);
-
-	Ref<Shader> preview_shader;
-	preview_shader.instance();
-	preview_shader->set_code(shader_code);
-	for (int i = 0; i < default_textures.size(); i++) {
-		preview_shader->set_default_texture_param(default_textures[i].name, default_textures[i].param);
-	}
-
-	Ref<ShaderMaterial> material;
-	material.instance();
-	material->set_shader(preview_shader);
-
-	//find if a material is also being edited and copy parameters to this one
-
-	for (int i = EditorNode::get_singleton()->get_editor_history()->get_path_size() - 1; i >= 0; i--) {
-		Object *object = ObjectDB::get_instance(EditorNode::get_singleton()->get_editor_history()->get_path_object(i));
-		ShaderMaterial *src_mat;
-		if (!object) {
-			continue;
-		}
-		if (object->has_method("get_material_override")) { // trying getting material from MeshInstance
-			src_mat = Object::cast_to<ShaderMaterial>(object->call("get_material_override"));
-		} else if (object->has_method("get_material")) { // from CanvasItem/Node2D
-			src_mat = Object::cast_to<ShaderMaterial>(object->call("get_material"));
-		} else {
-			src_mat = Object::cast_to<ShaderMaterial>(object);
-		}
-		if (src_mat && src_mat->get_shader().is_valid()) {
-			List<PropertyInfo> params;
-			src_mat->get_shader()->get_param_list(&params);
-			for (List<PropertyInfo>::Element *E = params.front(); E; E = E->next()) {
-				material->set(E->get().name, src_mat->get(E->get().name));
-			}
-		}
-	}
-
-	set_material(material);
-}
-
-void VisualShaderNodePortPreview::setup(const Ref<VisualShader> &p_shader, VisualShader::Type p_type, int p_node, int p_port) {
-	shader = p_shader;
-	shader->connect("changed", this, "_shader_changed");
-	type = p_type;
-	port = p_port;
-	node = p_node;
-	update();
-	_shader_changed();
-}
-
-Size2 VisualShaderNodePortPreview::get_minimum_size() const {
-	return Size2(100, 100) * EDSCALE;
-}
-
-void VisualShaderNodePortPreview::_notification(int p_what) {
-	if (p_what == NOTIFICATION_DRAW) {
-		Vector<Vector2> points;
-		Vector<Vector2> uvs;
-		Vector<Color> colors;
-		points.push_back(Vector2());
-		uvs.push_back(Vector2(0, 0));
-		colors.push_back(Color(1, 1, 1, 1));
-		points.push_back(Vector2(get_size().width, 0));
-		uvs.push_back(Vector2(1, 0));
-		colors.push_back(Color(1, 1, 1, 1));
-		points.push_back(get_size());
-		uvs.push_back(Vector2(1, 1));
-		colors.push_back(Color(1, 1, 1, 1));
-		points.push_back(Vector2(0, get_size().height));
-		uvs.push_back(Vector2(0, 1));
-		colors.push_back(Color(1, 1, 1, 1));
-
-		draw_primitive(points, colors, uvs);
-	}
-}
-
-void VisualShaderNodePortPreview::_bind_methods() {
-	ClassDB::bind_method("_shader_changed", &VisualShaderNodePortPreview::_shader_changed);
-}
-
-VisualShaderNodePortPreview::VisualShaderNodePortPreview() {
-}
-
-//////////////////////////////////
-
-String VisualShaderConversionPlugin::converts_to() const {
-	return "Shader";
-}
-
-bool VisualShaderConversionPlugin::handles(const Ref<Resource> &p_resource) const {
-	Ref<VisualShader> vshader = p_resource;
-	return vshader.is_valid();
-}
-
-Ref<Resource> VisualShaderConversionPlugin::convert(const Ref<Resource> &p_resource) const {
-	Ref<VisualShader> vshader = p_resource;
-	ERR_FAIL_COND_V(!vshader.is_valid(), Ref<Resource>());
-
-	Ref<Shader> shader;
-	shader.instance();
-
-	String code = vshader->get_code();
-	shader->set_code(code);
-
-	return shader;
-}
diff --git a/editor/plugins/visual_shader_editor_plugin.h b/editor/plugins/visual_shader_editor_plugin.h
deleted file mode 100644
index 18a908d9d..000000000
--- a/editor/plugins/visual_shader_editor_plugin.h
+++ /dev/null
@@ -1,357 +0,0 @@
-/*************************************************************************/
-/*  visual_shader_editor_plugin.h                                        */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef VISUAL_SHADER_EDITOR_PLUGIN_H
-#define VISUAL_SHADER_EDITOR_PLUGIN_H
-
-#include "editor/editor_node.h"
-#include "editor/editor_plugin.h"
-#include "editor/property_editor.h"
-#include "scene/gui/button.h"
-#include "scene/gui/graph_edit.h"
-#include "scene/gui/popup.h"
-#include "scene/gui/tree.h"
-#include "scene/resources/visual_shader.h"
-
-class VisualShaderNodePlugin : public Reference {
-	GDCLASS(VisualShaderNodePlugin, Reference);
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual Control *create_editor(const Ref<Resource> &p_parent_resource, const Ref<VisualShaderNode> &p_node);
-};
-
-class VisualShaderEditor : public VBoxContainer {
-	GDCLASS(VisualShaderEditor, VBoxContainer);
-
-	CustomPropertyEditor *property_editor;
-	int editing_node;
-	int editing_port;
-
-	Ref<VisualShader> visual_shader;
-	HSplitContainer *main_box;
-	GraphEdit *graph;
-	ToolButton *add_node;
-	ToolButton *preview_shader;
-
-	OptionButton *edit_type;
-
-	PanelContainer *error_panel;
-	Label *error_label;
-
-	bool pending_update_preview;
-	bool shader_error;
-	VBoxContainer *preview_vbox;
-	TextEdit *preview_text;
-	Label *error_text;
-
-	UndoRedo *undo_redo;
-	Point2 saved_node_pos;
-	bool saved_node_pos_dirty;
-
-	ConfirmationDialog *members_dialog;
-	MenuButton *tools;
-
-	bool preview_showed;
-
-	enum ToolsMenuOptions {
-		EXPAND_ALL,
-		COLLAPSE_ALL
-	};
-
-	Tree *members;
-	AcceptDialog *alert;
-	LineEdit *node_filter;
-	RichTextLabel *node_desc;
-
-	void _tools_menu_option(int p_idx);
-	void _show_members_dialog(bool at_mouse_pos);
-
-	void _update_graph();
-
-	struct AddOption {
-		String name;
-		String category;
-		String sub_category;
-		String type;
-		String description;
-		int sub_func;
-		String sub_func_str;
-		Ref<Script> script;
-		int mode;
-		int return_type;
-		int func;
-		float value;
-		bool highend;
-		bool is_custom;
-
-		AddOption(const String &p_name = String(), const String &p_category = String(), const String &p_sub_category = String(), const String &p_type = String(), const String &p_description = String(), int p_sub_func = -1, int p_return_type = -1, int p_mode = -1, int p_func = -1, float p_value = -1, bool p_highend = false) {
-			name = p_name;
-			type = p_type;
-			category = p_category;
-			sub_category = p_sub_category;
-			description = p_description;
-			sub_func = p_sub_func;
-			return_type = p_return_type;
-			mode = p_mode;
-			func = p_func;
-			value = p_value;
-			highend = p_highend;
-			is_custom = false;
-		}
-
-		AddOption(const String &p_name, const String &p_category, const String &p_sub_category, const String &p_type, const String &p_description, const String &p_sub_func, int p_return_type = -1, int p_mode = -1, int p_func = -1, float p_value = -1, bool p_highend = false) {
-			name = p_name;
-			type = p_type;
-			category = p_category;
-			sub_category = p_sub_category;
-			description = p_description;
-			sub_func = 0;
-			sub_func_str = p_sub_func;
-			return_type = p_return_type;
-			mode = p_mode;
-			func = p_func;
-			value = p_value;
-			highend = p_highend;
-			is_custom = false;
-		}
-	};
-
-	Vector<AddOption> add_options;
-	int texture_node_option_idx;
-	int custom_node_option_idx;
-	List<String> keyword_list;
-
-	void _draw_color_over_button(Object *obj, Color p_color);
-
-	void _add_custom_node(const String &p_path);
-	void _add_texture_node(const String &p_path);
-	VisualShaderNode *_add_node(int p_idx, int p_op_idx = -1);
-	void _update_options_menu();
-
-	void _show_preview_text();
-	void _update_preview();
-	String _get_description(int p_idx);
-
-	static VisualShaderEditor *singleton;
-
-	struct DragOp {
-		VisualShader::Type type;
-		int node;
-		Vector2 from;
-		Vector2 to;
-	};
-	List<DragOp> drag_buffer;
-	bool drag_dirty = false;
-	void _node_dragged(const Vector2 &p_from, const Vector2 &p_to, int p_node);
-	void _nodes_dragged();
-	bool updating;
-
-	void _connection_request(const String &p_from, int p_from_index, const String &p_to, int p_to_index);
-	void _disconnection_request(const String &p_from, int p_from_index, const String &p_to, int p_to_index);
-
-	void _scroll_changed(const Vector2 &p_scroll);
-	void _node_selected(Object *p_node);
-
-	void _delete_request(int);
-	void _on_nodes_delete();
-
-	void _node_changed(int p_id);
-
-	void _edit_port_default_input(Object *p_button, int p_node, int p_port);
-	void _port_edited();
-
-	int to_node;
-	int to_slot;
-	int from_node;
-	int from_slot;
-
-	void _connection_to_empty(const String &p_from, int p_from_slot, const Vector2 &p_release_position);
-	void _connection_from_empty(const String &p_to, int p_to_slot, const Vector2 &p_release_position);
-
-	void _line_edit_changed(const String &p_text, Object *line_edit, int p_node_id);
-	void _line_edit_focus_out(Object *line_edit, int p_node_id);
-
-	void _port_name_focus_out(Object *line_edit, int p_node_id, int p_port_id, bool p_output);
-
-	void _dup_copy_nodes(int p_type, List<int> &r_nodes, Set<int> &r_excluded);
-	void _dup_update_excluded(int p_type, Set<int> &r_excluded);
-	void _dup_paste_nodes(int p_type, int p_pasted_type, List<int> &r_nodes, Set<int> &r_excluded, const Vector2 &p_offset, bool p_select);
-
-	void _duplicate_nodes();
-
-	Vector2 selection_center;
-	int copy_type; // shader type
-	List<int> copy_nodes_buffer;
-	Set<int> copy_nodes_excluded_buffer;
-
-	void _clear_buffer();
-	void _copy_nodes();
-	void _paste_nodes();
-
-	Vector<Ref<VisualShaderNodePlugin>> plugins;
-
-	void _mode_selected(int p_id);
-	void _rebuild();
-
-	void _input_select_item(Ref<VisualShaderNodeInput> input, String name);
-	void _uniform_select_item(Ref<VisualShaderNodeUniformRef> p_uniform, String p_name);
-
-	void _add_input_port(int p_node, int p_port, int p_port_type, const String &p_name);
-	void _remove_input_port(int p_node, int p_port);
-	void _change_input_port_type(int p_type, int p_node, int p_port);
-	void _change_input_port_name(const String &p_text, Object *line_edit, int p_node, int p_port);
-
-	void _add_output_port(int p_node, int p_port, int p_port_type, const String &p_name);
-	void _remove_output_port(int p_node, int p_port);
-	void _change_output_port_type(int p_type, int p_node, int p_port);
-	void _change_output_port_name(const String &p_text, Object *line_edit, int p_node, int p_port);
-
-	void _expression_focus_out(Object *text_edit, int p_node);
-
-	void _set_node_size(int p_type, int p_node, const Size2 &p_size);
-	void _node_resized(const Vector2 &p_new_size, int p_type, int p_node);
-
-	void _preview_select_port(int p_node, int p_port);
-	void _graph_gui_input(const Ref<InputEvent> &p_event);
-
-	void _member_filter_changed(const String &p_text);
-	void _sbox_input(const Ref<InputEvent> &p_ie);
-	void _member_selected();
-	void _member_unselected();
-	void _member_create();
-	void _member_cancel();
-
-	Variant get_drag_data_fw(const Point2 &p_point, Control *p_from);
-	bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const;
-	void drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from);
-
-	bool _is_available(int p_mode);
-	void _update_created_node(GraphNode *node);
-
-protected:
-	void _notification(int p_what);
-	static void _bind_methods();
-
-public:
-	void update_custom_nodes();
-	void add_plugin(const Ref<VisualShaderNodePlugin> &p_plugin);
-	void remove_plugin(const Ref<VisualShaderNodePlugin> &p_plugin);
-
-	static VisualShaderEditor *get_singleton() { return singleton; }
-
-	void clear_custom_types();
-	void add_custom_type(const String &p_name, const Ref<Script> &p_script, const String &p_description, int p_return_icon_type, const String &p_category, const String &p_subcategory);
-
-	virtual Size2 get_minimum_size() const;
-	void edit(VisualShader *p_visual_shader);
-	VisualShaderEditor();
-};
-
-class VisualShaderEditorPlugin : public EditorPlugin {
-	GDCLASS(VisualShaderEditorPlugin, EditorPlugin);
-
-	VisualShaderEditor *visual_shader_editor;
-	EditorNode *editor;
-	Button *button;
-
-public:
-	virtual String get_name() const { return "VisualShader"; }
-	bool has_main_screen() const { return false; }
-	virtual void edit(Object *p_object);
-	virtual bool handles(Object *p_object) const;
-	virtual void make_visible(bool p_visible);
-
-	VisualShaderEditorPlugin(EditorNode *p_node);
-	~VisualShaderEditorPlugin();
-};
-
-class VisualShaderNodePluginDefault : public VisualShaderNodePlugin {
-	GDCLASS(VisualShaderNodePluginDefault, VisualShaderNodePlugin);
-
-public:
-	virtual Control *create_editor(const Ref<Resource> &p_parent_resource, const Ref<VisualShaderNode> &p_node);
-};
-
-class EditorPropertyShaderMode : public EditorProperty {
-	GDCLASS(EditorPropertyShaderMode, EditorProperty);
-	OptionButton *options;
-
-	void _option_selected(int p_which);
-
-protected:
-	static void _bind_methods();
-
-public:
-	void setup(const Vector<String> &p_options);
-	virtual void update_property();
-	void set_option_button_clip(bool p_enable);
-	EditorPropertyShaderMode();
-};
-
-class EditorInspectorShaderModePlugin : public EditorInspectorPlugin {
-	GDCLASS(EditorInspectorShaderModePlugin, EditorInspectorPlugin);
-
-public:
-	virtual bool can_handle(Object *p_object);
-	virtual void parse_begin(Object *p_object);
-	virtual bool parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage);
-	virtual void parse_end();
-};
-
-class VisualShaderNodePortPreview : public Control {
-	GDCLASS(VisualShaderNodePortPreview, Control);
-	Ref<VisualShader> shader;
-	VisualShader::Type type;
-	int node;
-	int port;
-	void _shader_changed(); //must regen
-protected:
-	void _notification(int p_what);
-	static void _bind_methods();
-
-public:
-	virtual Size2 get_minimum_size() const;
-	void setup(const Ref<VisualShader> &p_shader, VisualShader::Type p_type, int p_node, int p_port);
-	VisualShaderNodePortPreview();
-};
-
-class VisualShaderConversionPlugin : public EditorResourceConversionPlugin {
-	GDCLASS(VisualShaderConversionPlugin, EditorResourceConversionPlugin);
-
-public:
-	virtual String converts_to() const;
-	virtual bool handles(const Ref<Resource> &p_resource) const;
-	virtual Ref<Resource> convert(const Ref<Resource> &p_resource) const;
-};
-
-#endif // VISUAL_SHADER_EDITOR_PLUGIN_H
diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
index b96b67b12..8d50147fe 100644
--- a/scene/gui/control.cpp
+++ b/scene/gui/control.cpp
@@ -383,7 +383,7 @@ void Control::_get_property_list(List<PropertyInfo> *p_list) const {
 				hint |= PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_CHECKED;
 			}
 
-			p_list->push_back(PropertyInfo(Variant::OBJECT, "custom_shaders/" + E->get(), PROPERTY_HINT_RESOURCE_TYPE, "Shader,VisualShader", hint));
+			p_list->push_back(PropertyInfo(Variant::OBJECT, "custom_shaders/" + E->get(), PROPERTY_HINT_RESOURCE_TYPE, "Shader", hint));
 		}
 	}
 	{
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index d5e2507aa..10ab9e090 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -169,8 +169,6 @@
 #include "scene/resources/texture.h"
 #include "scene/resources/tile_set.h"
 #include "scene/resources/video_stream.h"
-#include "scene/resources/visual_shader.h"
-#include "scene/resources/visual_shader_nodes.h"
 #include "scene/resources/world.h"
 #include "scene/resources/world_2d.h"
 #include "scene/scene_string_names.h"
@@ -502,68 +500,6 @@ void register_scene_types() {
 	AcceptDialog::set_swap_ok_cancel(GLOBAL_DEF_NOVAL("gui/common/swap_ok_cancel", bool(OS::get_singleton()->get_swap_ok_cancel())));
 
 	ClassDB::register_class<Shader>();
-	ClassDB::register_class<VisualShader>();
-	ClassDB::register_virtual_class<VisualShaderNode>();
-	ClassDB::register_class<VisualShaderNodeCustom>();
-	ClassDB::register_class<VisualShaderNodeInput>();
-	ClassDB::register_virtual_class<VisualShaderNodeOutput>();
-	ClassDB::register_class<VisualShaderNodeGroupBase>();
-	ClassDB::register_class<VisualShaderNodeScalarConstant>();
-	ClassDB::register_class<VisualShaderNodeBooleanConstant>();
-	ClassDB::register_class<VisualShaderNodeColorConstant>();
-	ClassDB::register_class<VisualShaderNodeVec3Constant>();
-	ClassDB::register_class<VisualShaderNodeTransformConstant>();
-	ClassDB::register_class<VisualShaderNodeScalarOp>();
-	ClassDB::register_class<VisualShaderNodeVectorOp>();
-	ClassDB::register_class<VisualShaderNodeColorOp>();
-	ClassDB::register_class<VisualShaderNodeTransformMult>();
-	ClassDB::register_class<VisualShaderNodeTransformVecMult>();
-	ClassDB::register_class<VisualShaderNodeScalarFunc>();
-	ClassDB::register_class<VisualShaderNodeVectorFunc>();
-	ClassDB::register_class<VisualShaderNodeColorFunc>();
-	ClassDB::register_class<VisualShaderNodeTransformFunc>();
-	ClassDB::register_class<VisualShaderNodeDotProduct>();
-	ClassDB::register_class<VisualShaderNodeVectorLen>();
-	ClassDB::register_class<VisualShaderNodeDeterminant>();
-	ClassDB::register_class<VisualShaderNodeScalarDerivativeFunc>();
-	ClassDB::register_class<VisualShaderNodeVectorDerivativeFunc>();
-	ClassDB::register_class<VisualShaderNodeScalarClamp>();
-	ClassDB::register_class<VisualShaderNodeVectorClamp>();
-	ClassDB::register_class<VisualShaderNodeFaceForward>();
-	ClassDB::register_class<VisualShaderNodeOuterProduct>();
-	ClassDB::register_class<VisualShaderNodeVectorScalarStep>();
-	ClassDB::register_class<VisualShaderNodeScalarSmoothStep>();
-	ClassDB::register_class<VisualShaderNodeVectorSmoothStep>();
-	ClassDB::register_class<VisualShaderNodeVectorScalarSmoothStep>();
-	ClassDB::register_class<VisualShaderNodeVectorDistance>();
-	ClassDB::register_class<VisualShaderNodeVectorRefract>();
-	ClassDB::register_class<VisualShaderNodeScalarInterp>();
-	ClassDB::register_class<VisualShaderNodeVectorInterp>();
-	ClassDB::register_class<VisualShaderNodeVectorScalarMix>();
-	ClassDB::register_class<VisualShaderNodeVectorCompose>();
-	ClassDB::register_class<VisualShaderNodeTransformCompose>();
-	ClassDB::register_class<VisualShaderNodeVectorDecompose>();
-	ClassDB::register_class<VisualShaderNodeTransformDecompose>();
-	ClassDB::register_class<VisualShaderNodeTexture>();
-	ClassDB::register_class<VisualShaderNodeCubeMap>();
-	ClassDB::register_virtual_class<VisualShaderNodeUniform>();
-	ClassDB::register_class<VisualShaderNodeUniformRef>();
-	ClassDB::register_class<VisualShaderNodeScalarUniform>();
-	ClassDB::register_class<VisualShaderNodeBooleanUniform>();
-	ClassDB::register_class<VisualShaderNodeColorUniform>();
-	ClassDB::register_class<VisualShaderNodeVec3Uniform>();
-	ClassDB::register_class<VisualShaderNodeTransformUniform>();
-	ClassDB::register_class<VisualShaderNodeTextureUniform>();
-	ClassDB::register_class<VisualShaderNodeTextureUniformTriplanar>();
-	ClassDB::register_class<VisualShaderNodeCubeMapUniform>();
-	ClassDB::register_class<VisualShaderNodeIf>();
-	ClassDB::register_class<VisualShaderNodeSwitch>();
-	ClassDB::register_class<VisualShaderNodeScalarSwitch>();
-	ClassDB::register_class<VisualShaderNodeFresnel>();
-	ClassDB::register_class<VisualShaderNodeExpression>();
-	ClassDB::register_class<VisualShaderNodeGlobalExpression>();
-	ClassDB::register_class<VisualShaderNodeIs>();
-	ClassDB::register_class<VisualShaderNodeCompare>();
 
 	ClassDB::register_class<ShaderMaterial>();
 	ClassDB::register_virtual_class<CanvasItem>();
diff --git a/scene/resources/visual_shader.cpp b/scene/resources/visual_shader.cpp
deleted file mode 100644
index fe44caa2a..000000000
--- a/scene/resources/visual_shader.cpp
+++ /dev/null
@@ -1,2960 +0,0 @@
-/*************************************************************************/
-/*  visual_shader.cpp                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "visual_shader.h"
-
-#include "core/vmap.h"
-#include "servers/visual/shader_types.h"
-
-bool VisualShaderNode::is_simple_decl() const {
-	return simple_decl;
-}
-
-void VisualShaderNode::set_output_port_for_preview(int p_index) {
-	port_preview = p_index;
-}
-
-int VisualShaderNode::get_output_port_for_preview() const {
-	return port_preview;
-}
-
-void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p_value) {
-	default_input_values[p_port] = p_value;
-	emit_changed();
-}
-
-Variant VisualShaderNode::get_input_port_default_value(int p_port) const {
-	if (default_input_values.has(p_port)) {
-		return default_input_values[p_port];
-	}
-
-	return Variant();
-}
-
-bool VisualShaderNode::is_port_separator(int p_index) const {
-	return false;
-}
-
-bool VisualShaderNode::is_output_port_connected(int p_port) const {
-	if (connected_output_ports.has(p_port)) {
-		return connected_output_ports[p_port] > 0;
-	}
-	return false;
-}
-
-void VisualShaderNode::set_output_port_connected(int p_port, bool p_connected) {
-	if (p_connected) {
-		connected_output_ports[p_port]++;
-	} else {
-		connected_output_ports[p_port]--;
-	}
-}
-
-bool VisualShaderNode::is_input_port_connected(int p_port) const {
-	if (connected_input_ports.has(p_port)) {
-		return connected_input_ports[p_port];
-	}
-	return false;
-}
-
-void VisualShaderNode::set_input_port_connected(int p_port, bool p_connected) {
-	connected_input_ports[p_port] = p_connected;
-}
-
-bool VisualShaderNode::is_generate_input_var(int p_port) const {
-	return true;
-}
-
-bool VisualShaderNode::is_code_generated() const {
-	return true;
-}
-
-bool VisualShaderNode::is_show_prop_names() const {
-	return false;
-}
-
-Vector<VisualShader::DefaultTextureParam> VisualShaderNode::get_default_texture_parameters(VisualShader::Type p_type, int p_id) const {
-	return Vector<VisualShader::DefaultTextureParam>();
-}
-String VisualShaderNode::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	return String();
-}
-
-String VisualShaderNode::generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	return String();
-}
-
-String VisualShaderNode::generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	return String();
-}
-
-Vector<StringName> VisualShaderNode::get_editable_properties() const {
-	return Vector<StringName>();
-}
-
-Array VisualShaderNode::get_default_input_values() const {
-	Array ret;
-	for (Map<int, Variant>::Element *E = default_input_values.front(); E; E = E->next()) {
-		ret.push_back(E->key());
-		ret.push_back(E->get());
-	}
-	return ret;
-}
-void VisualShaderNode::set_default_input_values(const Array &p_values) {
-	if (p_values.size() % 2 == 0) {
-		for (int i = 0; i < p_values.size(); i += 2) {
-			default_input_values[p_values[i + 0]] = p_values[i + 1];
-		}
-	}
-
-	emit_changed();
-}
-
-String VisualShaderNode::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
-	return String();
-}
-
-String VisualShaderNode::get_input_port_default_hint(int p_port) const {
-	return "";
-}
-
-void VisualShaderNode::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_output_port_for_preview", "port"), &VisualShaderNode::set_output_port_for_preview);
-	ClassDB::bind_method(D_METHOD("get_output_port_for_preview"), &VisualShaderNode::get_output_port_for_preview);
-
-	ClassDB::bind_method(D_METHOD("set_input_port_default_value", "port", "value"), &VisualShaderNode::set_input_port_default_value);
-	ClassDB::bind_method(D_METHOD("get_input_port_default_value", "port"), &VisualShaderNode::get_input_port_default_value);
-
-	ClassDB::bind_method(D_METHOD("set_default_input_values", "values"), &VisualShaderNode::set_default_input_values);
-	ClassDB::bind_method(D_METHOD("get_default_input_values"), &VisualShaderNode::get_default_input_values);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "output_port_for_preview"), "set_output_port_for_preview", "get_output_port_for_preview");
-	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "default_input_values", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "set_default_input_values", "get_default_input_values");
-	ADD_SIGNAL(MethodInfo("editor_refresh_request"));
-
-	BIND_ENUM_CONSTANT(PORT_TYPE_SCALAR);
-	BIND_ENUM_CONSTANT(PORT_TYPE_VECTOR);
-	BIND_ENUM_CONSTANT(PORT_TYPE_BOOLEAN);
-	BIND_ENUM_CONSTANT(PORT_TYPE_TRANSFORM);
-	BIND_ENUM_CONSTANT(PORT_TYPE_SAMPLER);
-	BIND_ENUM_CONSTANT(PORT_TYPE_MAX);
-}
-
-VisualShaderNode::VisualShaderNode() {
-	port_preview = -1;
-	simple_decl = true;
-}
-
-/////////////////////////////////////////////////////////
-
-void VisualShaderNodeCustom::update_ports() {
-	ERR_FAIL_COND(!get_script_instance());
-
-	input_ports.clear();
-	if (get_script_instance()->has_method("_get_input_port_count")) {
-		int input_port_count = (int)get_script_instance()->call("_get_input_port_count");
-		bool has_name = get_script_instance()->has_method("_get_input_port_name");
-		bool has_type = get_script_instance()->has_method("_get_input_port_type");
-		for (int i = 0; i < input_port_count; i++) {
-			Port port;
-			if (has_name) {
-				port.name = (String)get_script_instance()->call("_get_input_port_name", i);
-			} else {
-				port.name = "in" + itos(i);
-			}
-			if (has_type) {
-				port.type = (int)get_script_instance()->call("_get_input_port_type", i);
-			} else {
-				port.type = (int)PortType::PORT_TYPE_SCALAR;
-			}
-			input_ports.push_back(port);
-		}
-	}
-	output_ports.clear();
-	if (get_script_instance()->has_method("_get_output_port_count")) {
-		int output_port_count = (int)get_script_instance()->call("_get_output_port_count");
-		bool has_name = get_script_instance()->has_method("_get_output_port_name");
-		bool has_type = get_script_instance()->has_method("_get_output_port_type");
-		for (int i = 0; i < output_port_count; i++) {
-			Port port;
-			if (has_name) {
-				port.name = (String)get_script_instance()->call("_get_output_port_name", i);
-			} else {
-				port.name = "out" + itos(i);
-			}
-			if (has_type) {
-				port.type = (int)get_script_instance()->call("_get_output_port_type", i);
-			} else {
-				port.type = (int)PortType::PORT_TYPE_SCALAR;
-			}
-			output_ports.push_back(port);
-		}
-	}
-}
-
-String VisualShaderNodeCustom::get_caption() const {
-	ERR_FAIL_COND_V(!get_script_instance(), "");
-	if (get_script_instance()->has_method("_get_name")) {
-		return (String)get_script_instance()->call("_get_name");
-	}
-	return "Unnamed";
-}
-
-int VisualShaderNodeCustom::get_input_port_count() const {
-	return input_ports.size();
-}
-
-VisualShaderNodeCustom::PortType VisualShaderNodeCustom::get_input_port_type(int p_port) const {
-	ERR_FAIL_INDEX_V(p_port, input_ports.size(), PORT_TYPE_SCALAR);
-	return (PortType)input_ports[p_port].type;
-}
-
-String VisualShaderNodeCustom::get_input_port_name(int p_port) const {
-	ERR_FAIL_INDEX_V(p_port, input_ports.size(), "");
-	return input_ports[p_port].name;
-}
-
-int VisualShaderNodeCustom::get_output_port_count() const {
-	return output_ports.size();
-}
-
-VisualShaderNodeCustom::PortType VisualShaderNodeCustom::get_output_port_type(int p_port) const {
-	ERR_FAIL_INDEX_V(p_port, output_ports.size(), PORT_TYPE_SCALAR);
-	return (PortType)output_ports[p_port].type;
-}
-
-String VisualShaderNodeCustom::get_output_port_name(int p_port) const {
-	ERR_FAIL_INDEX_V(p_port, output_ports.size(), "");
-	return output_ports[p_port].name;
-}
-
-String VisualShaderNodeCustom::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	ERR_FAIL_COND_V(!get_script_instance(), "");
-	ERR_FAIL_COND_V(!get_script_instance()->has_method("_get_code"), "");
-	Array input_vars;
-	for (int i = 0; i < get_input_port_count(); i++) {
-		input_vars.push_back(p_input_vars[i]);
-	}
-	Array output_vars;
-	for (int i = 0; i < get_output_port_count(); i++) {
-		output_vars.push_back(p_output_vars[i]);
-	}
-	String code = "\t{\n";
-	String _code = (String)get_script_instance()->call("_get_code", input_vars, output_vars, (int)p_mode, (int)p_type);
-	bool nend = _code.ends_with("\n");
-	_code = _code.insert(0, "\t\t");
-	_code = _code.replace("\n", "\n\t\t");
-	code += _code;
-	if (!nend) {
-		code += "\n\t}";
-	} else {
-		code.remove(code.size() - 1);
-		code += "}";
-	}
-	code += "\n";
-	return code;
-}
-
-String VisualShaderNodeCustom::generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	ERR_FAIL_COND_V(!get_script_instance(), "");
-	if (get_script_instance()->has_method("_get_global_code")) {
-		String code = "// " + get_caption() + "\n";
-		code += (String)get_script_instance()->call("_get_global_code", (int)p_mode);
-		code += "\n";
-		return code;
-	}
-	return "";
-}
-
-void VisualShaderNodeCustom::set_input_port_default_value(int p_port, const Variant &p_value) {
-	if (!is_initialized) {
-		VisualShaderNode::set_input_port_default_value(p_port, p_value);
-	}
-}
-
-void VisualShaderNodeCustom::set_default_input_values(const Array &p_values) {
-	if (!is_initialized) {
-		VisualShaderNode::set_default_input_values(p_values);
-	}
-}
-
-void VisualShaderNodeCustom::_set_input_port_default_value(int p_port, const Variant &p_value) {
-	VisualShaderNode::set_input_port_default_value(p_port, p_value);
-}
-
-bool VisualShaderNodeCustom::_is_initialized() {
-	return is_initialized;
-}
-
-void VisualShaderNodeCustom::_set_initialized(bool p_enabled) {
-	is_initialized = p_enabled;
-}
-
-void VisualShaderNodeCustom::_bind_methods() {
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_name"));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_description"));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_category"));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_subcategory"));
-	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_return_icon_type"));
-	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_input_port_count"));
-	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_input_port_type", PropertyInfo(Variant::INT, "port")));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_input_port_name", PropertyInfo(Variant::INT, "port")));
-	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_output_port_count"));
-	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_output_port_type", PropertyInfo(Variant::INT, "port")));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_output_port_name", PropertyInfo(Variant::INT, "port")));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_code", PropertyInfo(Variant::ARRAY, "input_vars"), PropertyInfo(Variant::ARRAY, "output_vars"), PropertyInfo(Variant::INT, "mode"), PropertyInfo(Variant::INT, "type")));
-	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_global_code", PropertyInfo(Variant::INT, "mode")));
-
-	ClassDB::bind_method(D_METHOD("_set_initialized", "enabled"), &VisualShaderNodeCustom::_set_initialized);
-	ClassDB::bind_method(D_METHOD("_is_initialized"), &VisualShaderNodeCustom::_is_initialized);
-	ClassDB::bind_method(D_METHOD("_set_input_port_default_value", "port", "value"), &VisualShaderNodeCustom::_set_input_port_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_initialized", "_is_initialized");
-}
-
-VisualShaderNodeCustom::VisualShaderNodeCustom() {
-	simple_decl = false;
-}
-
-/////////////////////////////////////////////////////////
-
-void VisualShader::add_node(Type p_type, const Ref<VisualShaderNode> &p_node, const Vector2 &p_position, int p_id) {
-	ERR_FAIL_COND(p_node.is_null());
-	ERR_FAIL_COND(p_id < 2);
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	Graph *g = &graph[p_type];
-	ERR_FAIL_COND(g->nodes.has(p_id));
-	Node n;
-	n.node = p_node;
-	n.position = p_position;
-
-	Ref<VisualShaderNodeUniform> uniform = n.node;
-	if (uniform.is_valid()) {
-		String valid_name = validate_uniform_name(uniform->get_uniform_name(), uniform);
-		uniform->set_uniform_name(valid_name);
-	}
-
-	Ref<VisualShaderNodeInput> input = n.node;
-	if (input.is_valid()) {
-		input->shader_mode = shader_mode;
-		input->shader_type = p_type;
-		input->connect("input_type_changed", this, "_input_type_changed", varray(p_type, p_id));
-	}
-
-	n.node->connect("changed", this, "_queue_update");
-
-	Ref<VisualShaderNodeCustom> custom = n.node;
-	if (custom.is_valid()) {
-		custom->update_ports();
-	}
-
-	g->nodes[p_id] = n;
-
-	_queue_update();
-}
-
-void VisualShader::set_node_position(Type p_type, int p_id, const Vector2 &p_position) {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	Graph *g = &graph[p_type];
-	ERR_FAIL_COND(!g->nodes.has(p_id));
-	g->nodes[p_id].position = p_position;
-}
-
-Vector2 VisualShader::get_node_position(Type p_type, int p_id) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, Vector2());
-	const Graph *g = &graph[p_type];
-	ERR_FAIL_COND_V(!g->nodes.has(p_id), Vector2());
-	return g->nodes[p_id].position;
-}
-
-Ref<VisualShaderNode> VisualShader::get_node(Type p_type, int p_id) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, Ref<VisualShaderNode>());
-	const Graph *g = &graph[p_type];
-	ERR_FAIL_COND_V(!g->nodes.has(p_id), Ref<VisualShaderNode>());
-	return g->nodes[p_id].node;
-}
-
-Vector<int> VisualShader::get_node_list(Type p_type) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, Vector<int>());
-	const Graph *g = &graph[p_type];
-
-	Vector<int> ret;
-	for (Map<int, Node>::Element *E = g->nodes.front(); E; E = E->next()) {
-		ret.push_back(E->key());
-	}
-
-	return ret;
-}
-int VisualShader::get_valid_node_id(Type p_type) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, NODE_ID_INVALID);
-	const Graph *g = &graph[p_type];
-	return g->nodes.size() ? MAX(2, g->nodes.back()->key() + 1) : 2;
-}
-
-int VisualShader::find_node_id(Type p_type, const Ref<VisualShaderNode> &p_node) const {
-	for (const Map<int, Node>::Element *E = graph[p_type].nodes.front(); E; E = E->next()) {
-		if (E->get().node == p_node) {
-			return E->key();
-		}
-	}
-
-	return NODE_ID_INVALID;
-}
-
-void VisualShader::remove_node(Type p_type, int p_id) {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	ERR_FAIL_COND(p_id < 2);
-	Graph *g = &graph[p_type];
-	ERR_FAIL_COND(!g->nodes.has(p_id));
-
-	Ref<VisualShaderNodeInput> input = g->nodes[p_id].node;
-	if (input.is_valid()) {
-		input->disconnect("input_type_changed", this, "_input_type_changed");
-	}
-
-	g->nodes[p_id].node->disconnect("changed", this, "_queue_update");
-
-	g->nodes.erase(p_id);
-
-	for (List<Connection>::Element *E = g->connections.front(); E;) {
-		List<Connection>::Element *N = E->next();
-		if (E->get().from_node == p_id || E->get().to_node == p_id) {
-			g->connections.erase(E);
-			if (E->get().from_node == p_id) {
-				g->nodes[E->get().to_node].prev_connected_nodes.erase(p_id);
-				g->nodes[E->get().to_node].node->set_input_port_connected(E->get().to_port, false);
-			}
-		}
-		E = N;
-	}
-
-	_queue_update();
-}
-
-bool VisualShader::is_node_connection(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, false);
-	const Graph *g = &graph[p_type];
-
-	for (const List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-bool VisualShader::is_nodes_connected_relatively(const Graph *p_graph, int p_node, int p_target) const {
-	bool result = false;
-
-	const VisualShader::Node &node = p_graph->nodes[p_node];
-
-	for (const List<int>::Element *E = node.prev_connected_nodes.front(); E; E = E->next()) {
-		if (E->get() == p_target) {
-			return true;
-		}
-
-		result = is_nodes_connected_relatively(p_graph, E->get(), p_target);
-		if (result) {
-			break;
-		}
-	}
-	return result;
-}
-
-bool VisualShader::can_connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, false);
-	const Graph *g = &graph[p_type];
-
-	if (!g->nodes.has(p_from_node)) {
-		return false;
-	}
-
-	if (p_from_node == p_to_node) {
-		return false;
-	}
-
-	if (p_from_port < 0 || p_from_port >= g->nodes[p_from_node].node->get_output_port_count()) {
-		return false;
-	}
-
-	if (!g->nodes.has(p_to_node)) {
-		return false;
-	}
-
-	if (p_to_port < 0 || p_to_port >= g->nodes[p_to_node].node->get_input_port_count()) {
-		return false;
-	}
-
-	VisualShaderNode::PortType from_port_type = g->nodes[p_from_node].node->get_output_port_type(p_from_port);
-	VisualShaderNode::PortType to_port_type = g->nodes[p_to_node].node->get_input_port_type(p_to_port);
-
-	if (!is_port_types_compatible(from_port_type, to_port_type)) {
-		return false;
-	}
-
-	for (const List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {
-			return false;
-		}
-	}
-
-	if (is_nodes_connected_relatively(g, p_from_node, p_to_node)) {
-		return false;
-	}
-
-	return true;
-}
-
-bool VisualShader::is_port_types_compatible(int p_a, int p_b) const {
-	return MAX(0, p_a - 2) == (MAX(0, p_b - 2));
-}
-
-void VisualShader::connect_nodes_forced(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	Graph *g = &graph[p_type];
-
-	ERR_FAIL_COND(!g->nodes.has(p_from_node));
-	ERR_FAIL_INDEX(p_from_port, g->nodes[p_from_node].node->get_output_port_count());
-	ERR_FAIL_COND(!g->nodes.has(p_to_node));
-	ERR_FAIL_INDEX(p_to_port, g->nodes[p_to_node].node->get_input_port_count());
-
-	Connection c;
-	c.from_node = p_from_node;
-	c.from_port = p_from_port;
-	c.to_node = p_to_node;
-	c.to_port = p_to_port;
-	g->connections.push_back(c);
-	g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
-	g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
-	g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
-
-	_queue_update();
-}
-
-Error VisualShader::connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, ERR_CANT_CONNECT);
-	Graph *g = &graph[p_type];
-
-	ERR_FAIL_COND_V(!g->nodes.has(p_from_node), ERR_INVALID_PARAMETER);
-	ERR_FAIL_INDEX_V(p_from_port, g->nodes[p_from_node].node->get_output_port_count(), ERR_INVALID_PARAMETER);
-	ERR_FAIL_COND_V(!g->nodes.has(p_to_node), ERR_INVALID_PARAMETER);
-	ERR_FAIL_INDEX_V(p_to_port, g->nodes[p_to_node].node->get_input_port_count(), ERR_INVALID_PARAMETER);
-
-	VisualShaderNode::PortType from_port_type = g->nodes[p_from_node].node->get_output_port_type(p_from_port);
-	VisualShaderNode::PortType to_port_type = g->nodes[p_to_node].node->get_input_port_type(p_to_port);
-
-	ERR_FAIL_COND_V_MSG(!is_port_types_compatible(from_port_type, to_port_type), ERR_INVALID_PARAMETER, "Incompatible port types (scalar/vec/bool) with transform.");
-
-	for (List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {
-			ERR_FAIL_V(ERR_ALREADY_EXISTS);
-		}
-	}
-
-	Connection c;
-	c.from_node = p_from_node;
-	c.from_port = p_from_port;
-	c.to_node = p_to_node;
-	c.to_port = p_to_port;
-	g->connections.push_back(c);
-	g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
-	g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
-	g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
-
-	_queue_update();
-	return OK;
-}
-
-void VisualShader::disconnect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	Graph *g = &graph[p_type];
-
-	for (List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {
-			g->connections.erase(E);
-			g->nodes[p_to_node].prev_connected_nodes.erase(p_from_node);
-			g->nodes[p_from_node].node->set_output_port_connected(p_from_port, false);
-			g->nodes[p_to_node].node->set_input_port_connected(p_to_port, false);
-			_queue_update();
-			return;
-		}
-	}
-}
-
-Array VisualShader::_get_node_connections(Type p_type) const {
-	ERR_FAIL_INDEX_V(p_type, TYPE_MAX, Array());
-	const Graph *g = &graph[p_type];
-
-	Array ret;
-	for (const List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		Dictionary d;
-		d["from_node"] = E->get().from_node;
-		d["from_port"] = E->get().from_port;
-		d["to_node"] = E->get().to_node;
-		d["to_port"] = E->get().to_port;
-		ret.push_back(d);
-	}
-
-	return ret;
-}
-
-void VisualShader::get_node_connections(Type p_type, List<Connection> *r_connections) const {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	const Graph *g = &graph[p_type];
-
-	for (const List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
-		r_connections->push_back(E->get());
-	}
-}
-
-void VisualShader::set_mode(Mode p_mode) {
-	ERR_FAIL_INDEX_MSG(p_mode, Mode::MODE_MAX, vformat("Invalid shader mode: %d.", p_mode));
-
-	if (shader_mode == p_mode) {
-		return;
-	}
-
-	//erase input/output connections
-	modes.clear();
-	flags.clear();
-	shader_mode = p_mode;
-	for (int i = 0; i < TYPE_MAX; i++) {
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			Ref<VisualShaderNodeInput> input = E->get().node;
-			if (input.is_valid()) {
-				input->shader_mode = shader_mode;
-				//input->input_index = 0;
-			}
-		}
-
-		Ref<VisualShaderNodeOutput> output = graph[i].nodes[NODE_ID_OUTPUT].node;
-		output->shader_mode = shader_mode;
-
-		// clear connections since they are no longer valid
-		for (List<Connection>::Element *E = graph[i].connections.front(); E;) {
-			bool keep = true;
-
-			List<Connection>::Element *N = E->next();
-
-			int from = E->get().from_node;
-			int to = E->get().to_node;
-
-			if (!graph[i].nodes.has(from)) {
-				keep = false;
-			} else {
-				Ref<VisualShaderNode> from_node = graph[i].nodes[from].node;
-				if (from_node->is_class("VisualShaderNodeOutput") || from_node->is_class("VisualShaderNodeInput")) {
-					keep = false;
-				}
-			}
-
-			if (!graph[i].nodes.has(to)) {
-				keep = false;
-			} else {
-				Ref<VisualShaderNode> to_node = graph[i].nodes[to].node;
-				if (to_node->is_class("VisualShaderNodeOutput") || to_node->is_class("VisualShaderNodeInput")) {
-					keep = false;
-				}
-			}
-
-			if (!keep) {
-				graph[i].connections.erase(E);
-			}
-			E = N;
-		}
-	}
-
-	_queue_update();
-	_change_notify();
-}
-
-void VisualShader::set_graph_offset(const Vector2 &p_offset) {
-	graph_offset = p_offset;
-}
-
-Vector2 VisualShader::get_graph_offset() const {
-	return graph_offset;
-}
-
-Shader::Mode VisualShader::get_mode() const {
-	return shader_mode;
-}
-
-bool VisualShader::is_text_shader() const {
-	return false;
-}
-
-String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port, Vector<DefaultTextureParam> &default_tex_params) const {
-	Ref<VisualShaderNode> node = get_node(p_type, p_node);
-	ERR_FAIL_COND_V(!node.is_valid(), String());
-	ERR_FAIL_COND_V(p_port < 0 || p_port >= node->get_output_port_count(), String());
-	ERR_FAIL_COND_V(node->get_output_port_type(p_port) == VisualShaderNode::PORT_TYPE_TRANSFORM, String());
-
-	StringBuilder global_code;
-	StringBuilder global_code_per_node;
-	Map<Type, StringBuilder> global_code_per_func;
-	StringBuilder code;
-	Set<StringName> classes;
-
-	global_code += String() + "shader_type canvas_item;\n";
-
-	String global_expressions;
-	for (int i = 0, index = 0; i < TYPE_MAX; i++) {
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			Ref<VisualShaderNodeGlobalExpression> global_expression = Object::cast_to<VisualShaderNodeGlobalExpression>(E->get().node.ptr());
-			if (global_expression.is_valid()) {
-				String expr = "";
-				expr += "// " + global_expression->get_caption() + ":" + itos(index++) + "\n";
-				expr += global_expression->generate_global(get_mode(), Type(i), -1);
-				expr = expr.replace("\n", "\n\t");
-				expr += "\n";
-				global_expressions += expr;
-			}
-		}
-	}
-
-	global_code += "\n";
-	global_code += global_expressions;
-
-	//make it faster to go around through shader
-	VMap<ConnectionKey, const List<Connection>::Element *> input_connections;
-	VMap<ConnectionKey, const List<Connection>::Element *> output_connections;
-
-	for (const List<Connection>::Element *E = graph[p_type].connections.front(); E; E = E->next()) {
-		ConnectionKey from_key;
-		from_key.node = E->get().from_node;
-		from_key.port = E->get().from_port;
-
-		output_connections.insert(from_key, E);
-
-		ConnectionKey to_key;
-		to_key.node = E->get().to_node;
-		to_key.port = E->get().to_port;
-
-		input_connections.insert(to_key, E);
-	}
-
-	code += "\nvoid fragment() {\n";
-
-	Set<int> processed;
-	Error err = _write_node(p_type, global_code, global_code_per_node, global_code_per_func, code, default_tex_params, input_connections, output_connections, p_node, processed, true, classes);
-	ERR_FAIL_COND_V(err != OK, String());
-
-	if (node->get_output_port_type(p_port) == VisualShaderNode::PORT_TYPE_SCALAR) {
-		code += "\tCOLOR.rgb = vec3( n_out" + itos(p_node) + "p" + itos(p_port) + " );\n";
-	} else if (node->get_output_port_type(p_port) == VisualShaderNode::PORT_TYPE_BOOLEAN) {
-		code += "\tCOLOR.rgb = vec3( n_out" + itos(p_node) + "p" + itos(p_port) + " ? 1.0 : 0.0 );\n";
-	} else {
-		code += "\tCOLOR.rgb = n_out" + itos(p_node) + "p" + itos(p_port) + ";\n";
-	}
-	code += "}\n";
-
-	//set code secretly
-	global_code += "\n\n";
-	String final_code = global_code;
-	final_code += global_code_per_node;
-	final_code += code;
-	return final_code;
-}
-
-#define IS_INITIAL_CHAR(m_d) (((m_d) >= 'a' && (m_d) <= 'z') || ((m_d) >= 'A' && (m_d) <= 'Z'))
-
-#define IS_SYMBOL_CHAR(m_d) (((m_d) >= 'a' && (m_d) <= 'z') || ((m_d) >= 'A' && (m_d) <= 'Z') || ((m_d) >= '0' && (m_d) <= '9') || (m_d) == '_')
-
-String VisualShader::validate_port_name(const String &p_name, const List<String> &p_input_ports, const List<String> &p_output_ports) const {
-	String name = p_name;
-
-	while (name.length() && !IS_INITIAL_CHAR(name[0])) {
-		name = name.substr(1, name.length() - 1);
-	}
-
-	if (name != String()) {
-		String valid_name;
-
-		for (int i = 0; i < name.length(); i++) {
-			if (IS_SYMBOL_CHAR(name[i])) {
-				valid_name += String::chr(name[i]);
-			} else if (name[i] == ' ') {
-				valid_name += "_";
-			}
-		}
-
-		name = valid_name;
-	}
-
-	String valid_name = name;
-	bool is_equal = false;
-
-	for (int i = 0; i < p_input_ports.size(); i++) {
-		if (name == p_input_ports[i]) {
-			is_equal = true;
-			break;
-		}
-	}
-
-	if (!is_equal) {
-		for (int i = 0; i < p_output_ports.size(); i++) {
-			if (name == p_output_ports[i]) {
-				is_equal = true;
-				break;
-			}
-		}
-	}
-
-	if (is_equal) {
-		name = "";
-	}
-
-	return name;
-}
-
-String VisualShader::validate_uniform_name(const String &p_name, const Ref<VisualShaderNodeUniform> &p_uniform) const {
-	String name = p_name; //validate name first
-	while (name.length() && !IS_INITIAL_CHAR(name[0])) {
-		name = name.substr(1, name.length() - 1);
-	}
-	if (name != String()) {
-		String valid_name;
-
-		for (int i = 0; i < name.length(); i++) {
-			if (IS_SYMBOL_CHAR(name[i])) {
-				valid_name += String::chr(name[i]);
-			} else if (name[i] == ' ') {
-				valid_name += "_";
-			}
-		}
-
-		name = valid_name;
-	}
-
-	if (name == String()) {
-		name = p_uniform->get_caption();
-	}
-
-	int attempt = 1;
-
-	while (true) {
-		bool exists = false;
-		for (int i = 0; i < TYPE_MAX; i++) {
-			for (const Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-				Ref<VisualShaderNodeUniform> node = E->get().node;
-				if (node == p_uniform) { //do not test on self
-					continue;
-				}
-				if (node.is_valid() && node->get_uniform_name() == name) {
-					exists = true;
-					break;
-				}
-			}
-			if (exists) {
-				break;
-			}
-		}
-
-		if (exists) {
-			//remove numbers, put new and try again
-			attempt++;
-			while (name.length() && name[name.length() - 1] >= '0' && name[name.length() - 1] <= '9') {
-				name = name.substr(0, name.length() - 1);
-			}
-			ERR_FAIL_COND_V(name == String(), String());
-			name += itos(attempt);
-		} else {
-			break;
-		}
-	}
-
-	return name;
-}
-
-VisualShader::RenderModeEnums VisualShader::render_mode_enums[] = {
-	{ Shader::MODE_SPATIAL, "blend" },
-	{ Shader::MODE_SPATIAL, "depth_draw" },
-	{ Shader::MODE_SPATIAL, "cull" },
-	{ Shader::MODE_SPATIAL, "diffuse" },
-	{ Shader::MODE_SPATIAL, "specular" },
-	{ Shader::MODE_SPATIAL, "async" },
-	{ Shader::MODE_CANVAS_ITEM, "blend" },
-	{ Shader::MODE_CANVAS_ITEM, nullptr }
-};
-
-static const char *type_string[VisualShader::TYPE_MAX] = {
-	"vertex",
-	"fragment",
-	"light"
-};
-bool VisualShader::_set(const StringName &p_name, const Variant &p_value) {
-	String name = p_name;
-	if (name == "mode") {
-		set_mode(Shader::Mode(int(p_value)));
-		return true;
-	} else if (name.begins_with("flags/")) {
-		StringName flag = name.get_slicec('/', 1);
-		bool enable = p_value;
-		if (enable) {
-			flags.insert(flag);
-		} else {
-			flags.erase(flag);
-		}
-		_queue_update();
-		return true;
-	} else if (name.begins_with("modes/")) {
-		String mode = name.get_slicec('/', 1);
-		int value = p_value;
-		if (value == 0) {
-			modes.erase(mode); //means it's default anyway, so don't store it
-		} else {
-			modes[mode] = value;
-		}
-		_queue_update();
-		return true;
-	} else if (name.begins_with("nodes/")) {
-		String typestr = name.get_slicec('/', 1);
-		Type type = TYPE_VERTEX;
-		for (int i = 0; i < TYPE_MAX; i++) {
-			if (typestr == type_string[i]) {
-				type = Type(i);
-				break;
-			}
-		}
-
-		String index = name.get_slicec('/', 2);
-		if (index == "connections") {
-			Vector<int> conns = p_value;
-			if (conns.size() % 4 == 0) {
-				for (int i = 0; i < conns.size(); i += 4) {
-					connect_nodes_forced(type, conns[i + 0], conns[i + 1], conns[i + 2], conns[i + 3]);
-				}
-			}
-			return true;
-		}
-
-		int id = index.to_int();
-		String what = name.get_slicec('/', 3);
-
-		if (what == "node") {
-			add_node(type, p_value, Vector2(), id);
-			return true;
-		} else if (what == "position") {
-			set_node_position(type, id, p_value);
-			return true;
-		} else if (what == "size") {
-			((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->set_size(p_value);
-			return true;
-		} else if (what == "input_ports") {
-			((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->set_inputs(p_value);
-			return true;
-		} else if (what == "output_ports") {
-			((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->set_outputs(p_value);
-			return true;
-		} else if (what == "expression") {
-			((VisualShaderNodeExpression *)get_node(type, id).ptr())->set_expression(p_value);
-			return true;
-		}
-	}
-	return false;
-}
-
-bool VisualShader::_get(const StringName &p_name, Variant &r_ret) const {
-	String name = p_name;
-	if (name == "mode") {
-		r_ret = get_mode();
-		return true;
-	} else if (name.begins_with("flags/")) {
-		StringName flag = name.get_slicec('/', 1);
-		r_ret = flags.has(flag);
-		return true;
-	} else if (name.begins_with("modes/")) {
-		String mode = name.get_slicec('/', 1);
-		if (modes.has(mode)) {
-			r_ret = modes[mode];
-		} else {
-			r_ret = 0;
-		}
-		return true;
-	} else if (name.begins_with("nodes/")) {
-		String typestr = name.get_slicec('/', 1);
-		Type type = TYPE_VERTEX;
-		for (int i = 0; i < TYPE_MAX; i++) {
-			if (typestr == type_string[i]) {
-				type = Type(i);
-				break;
-			}
-		}
-
-		String index = name.get_slicec('/', 2);
-		if (index == "connections") {
-			Vector<int> conns;
-			for (const List<Connection>::Element *E = graph[type].connections.front(); E; E = E->next()) {
-				conns.push_back(E->get().from_node);
-				conns.push_back(E->get().from_port);
-				conns.push_back(E->get().to_node);
-				conns.push_back(E->get().to_port);
-			}
-
-			r_ret = conns;
-			return true;
-		}
-
-		int id = index.to_int();
-		String what = name.get_slicec('/', 3);
-
-		if (what == "node") {
-			r_ret = get_node(type, id);
-			return true;
-		} else if (what == "position") {
-			r_ret = get_node_position(type, id);
-			return true;
-		} else if (what == "size") {
-			r_ret = ((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->get_size();
-			return true;
-		} else if (what == "input_ports") {
-			r_ret = ((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->get_inputs();
-			return true;
-		} else if (what == "output_ports") {
-			r_ret = ((VisualShaderNodeGroupBase *)get_node(type, id).ptr())->get_outputs();
-			return true;
-		} else if (what == "expression") {
-			r_ret = ((VisualShaderNodeExpression *)get_node(type, id).ptr())->get_expression();
-			return true;
-		}
-	}
-	return false;
-}
-void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
-	//mode
-	p_list->push_back(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Spatial,CanvasItem,Particles"));
-	//render modes
-
-	Map<String, String> blend_mode_enums;
-	Set<String> toggles;
-
-	for (int i = 0; i < ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode)).size(); i++) {
-		String mode = ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode))[i];
-		int idx = 0;
-		bool in_enum = false;
-		while (render_mode_enums[idx].string) {
-			if (mode.begins_with(render_mode_enums[idx].string)) {
-				String begin = render_mode_enums[idx].string;
-				String option = mode.replace_first(begin + "_", "");
-				if (!blend_mode_enums.has(begin)) {
-					blend_mode_enums[begin] = option;
-				} else {
-					blend_mode_enums[begin] += "," + option;
-				}
-				in_enum = true;
-				break;
-			}
-			idx++;
-		}
-
-		if (!in_enum) {
-			toggles.insert(mode);
-		}
-	}
-
-	for (Map<String, String>::Element *E = blend_mode_enums.front(); E; E = E->next()) {
-		p_list->push_back(PropertyInfo(Variant::INT, "modes/" + E->key(), PROPERTY_HINT_ENUM, E->get()));
-	}
-
-	for (Set<String>::Element *E = toggles.front(); E; E = E->next()) {
-		p_list->push_back(PropertyInfo(Variant::BOOL, "flags/" + E->get()));
-	}
-
-	for (int i = 0; i < TYPE_MAX; i++) {
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			String prop_name = "nodes/";
-			prop_name += type_string[i];
-			prop_name += "/" + itos(E->key());
-
-			if (E->key() != NODE_ID_OUTPUT) {
-				p_list->push_back(PropertyInfo(Variant::OBJECT, prop_name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "VisualShaderNode", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
-			}
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, prop_name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-
-			if (Object::cast_to<VisualShaderNodeGroupBase>(E->get().node.ptr()) != nullptr) {
-				p_list->push_back(PropertyInfo(Variant::VECTOR2, prop_name + "/size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-				p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/input_ports", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-				p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/output_ports", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-			}
-			if (Object::cast_to<VisualShaderNodeExpression>(E->get().node.ptr()) != nullptr) {
-				p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/expression", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-			}
-		}
-		p_list->push_back(PropertyInfo(Variant::POOL_INT_ARRAY, "nodes/" + String(type_string[i]) + "/connections", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-	}
-}
-
-Error VisualShader::_write_node(Type type, StringBuilder &global_code, StringBuilder &global_code_per_node, Map<Type, StringBuilder> &global_code_per_func, StringBuilder &code, Vector<VisualShader::DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, Set<int> &processed, bool for_preview, Set<StringName> &r_classes) const {
-	const Ref<VisualShaderNode> vsnode = graph[type].nodes[node].node;
-
-	//check inputs recursively first
-	int input_count = vsnode->get_input_port_count();
-	for (int i = 0; i < input_count; i++) {
-		ConnectionKey ck;
-		ck.node = node;
-		ck.port = i;
-
-		if (input_connections.has(ck)) {
-			int from_node = input_connections[ck]->get().from_node;
-			if (processed.has(from_node)) {
-				continue;
-			}
-
-			Error err = _write_node(type, global_code, global_code_per_node, global_code_per_func, code, def_tex_params, input_connections, output_connections, from_node, processed, for_preview, r_classes);
-			if (err) {
-				return err;
-			}
-		}
-	}
-
-	// then this node
-
-	Vector<VisualShader::DefaultTextureParam> params = vsnode->get_default_texture_parameters(type, node);
-	for (int i = 0; i < params.size(); i++) {
-		def_tex_params.push_back(params[i]);
-	}
-
-	Ref<VisualShaderNodeInput> input = vsnode;
-	bool skip_global = input.is_valid() && for_preview;
-
-	if (!skip_global) {
-		global_code += vsnode->generate_global(get_mode(), type, node);
-
-		String class_name = vsnode->get_class_name();
-		if (class_name == "VisualShaderNodeCustom") {
-			class_name = vsnode->get_script_instance()->get_script()->get_path();
-		}
-		if (!r_classes.has(class_name)) {
-			global_code_per_node += vsnode->generate_global_per_node(get_mode(), type, node);
-			for (int i = 0; i < TYPE_MAX; i++) {
-				global_code_per_func[Type(i)] += vsnode->generate_global_per_func(get_mode(), Type(i), node);
-			}
-			r_classes.insert(class_name);
-		}
-	}
-
-	if (!vsnode->is_code_generated()) { // just generate globals and ignore locals
-		processed.insert(node);
-		return OK;
-	}
-
-	code += "// " + vsnode->get_caption() + ":" + itos(node) + "\n";
-	Vector<String> input_vars;
-
-	input_vars.resize(vsnode->get_input_port_count());
-	String *inputs = input_vars.ptrw();
-
-	for (int i = 0; i < input_count; i++) {
-		ConnectionKey ck;
-		ck.node = node;
-		ck.port = i;
-
-		if (input_connections.has(ck)) {
-			//connected to something, use that output
-			int from_node = input_connections[ck]->get().from_node;
-			int from_port = input_connections[ck]->get().from_port;
-
-			VisualShaderNode::PortType in_type = vsnode->get_input_port_type(i);
-			VisualShaderNode::PortType out_type = graph[type].nodes[from_node].node->get_output_port_type(from_port);
-
-			String src_var = "n_out" + itos(from_node) + "p" + itos(from_port);
-
-			if (in_type == VisualShaderNode::PORT_TYPE_SAMPLER && out_type == VisualShaderNode::PORT_TYPE_SAMPLER) {
-				VisualShaderNode *ptr = const_cast<VisualShaderNode *>(graph[type].nodes[from_node].node.ptr());
-				if (ptr->has_method("get_input_real_name")) {
-					inputs[i] = ptr->call("get_input_real_name");
-				} else if (ptr->has_method("get_uniform_name")) {
-					inputs[i] = ptr->call("get_uniform_name");
-				} else {
-					inputs[i] = "";
-				}
-			} else if (in_type == out_type) {
-				inputs[i] = src_var;
-			} else if (in_type == VisualShaderNode::PORT_TYPE_SCALAR && out_type == VisualShaderNode::PORT_TYPE_VECTOR) {
-				inputs[i] = "dot(" + src_var + ", vec3(0.333333, 0.333333, 0.333333))";
-			} else if (in_type == VisualShaderNode::PORT_TYPE_VECTOR && out_type == VisualShaderNode::PORT_TYPE_SCALAR) {
-				inputs[i] = "vec3(" + src_var + ")";
-			} else if (in_type == VisualShaderNode::PORT_TYPE_BOOLEAN && out_type == VisualShaderNode::PORT_TYPE_VECTOR) {
-				inputs[i] = "all(bvec3(" + src_var + "))";
-			} else if (in_type == VisualShaderNode::PORT_TYPE_BOOLEAN && out_type == VisualShaderNode::PORT_TYPE_SCALAR) {
-				inputs[i] = src_var + " > 0.0 ? true : false";
-			} else if (in_type == VisualShaderNode::PORT_TYPE_SCALAR && out_type == VisualShaderNode::PORT_TYPE_BOOLEAN) {
-				inputs[i] = "(" + src_var + " ? 1.0 : 0.0)";
-			} else if (in_type == VisualShaderNode::PORT_TYPE_VECTOR && out_type == VisualShaderNode::PORT_TYPE_BOOLEAN) {
-				inputs[i] = "vec3(" + src_var + " ? 1.0 : 0.0)";
-			}
-		} else {
-			if (!vsnode->is_generate_input_var(i)) {
-				continue;
-			}
-
-			Variant defval = vsnode->get_input_port_default_value(i);
-			if (defval.get_type() == Variant::REAL || defval.get_type() == Variant::INT) {
-				float val = defval;
-				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
-				code += "\tfloat " + inputs[i] + " = " + vformat("%.5f", val) + ";\n";
-			} else if (defval.get_type() == Variant::BOOL) {
-				bool val = defval;
-				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
-				code += "\tbool " + inputs[i] + " = " + (val ? "true" : "false") + ";\n";
-			} else if (defval.get_type() == Variant::VECTOR3) {
-				Vector3 val = defval;
-				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
-				code += "\tvec3 " + inputs[i] + " = " + vformat("vec3(%.5f, %.5f, %.5f);\n", val.x, val.y, val.z);
-			} else if (defval.get_type() == Variant::TRANSFORM) {
-				Transform val = defval;
-				val.basis.transpose();
-				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
-				Array values;
-				for (int j = 0; j < 3; j++) {
-					values.push_back(val.basis[j].x);
-					values.push_back(val.basis[j].y);
-					values.push_back(val.basis[j].z);
-				}
-				values.push_back(val.origin.x);
-				values.push_back(val.origin.y);
-				values.push_back(val.origin.z);
-				bool err = false;
-				code += "\tmat4 " + inputs[i] + " = " + String("mat4(vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 1.0));\n").sprintf(values, &err);
-			} else {
-				//will go empty, node is expected to know what it is doing at this point and handle it
-			}
-		}
-	}
-
-	int output_count = vsnode->get_output_port_count();
-	Vector<String> output_vars;
-	output_vars.resize(vsnode->get_output_port_count());
-	String *outputs = output_vars.ptrw();
-
-	if (vsnode->is_simple_decl()) { // less code to generate for some simple_decl nodes
-		for (int i = 0; i < output_count; i++) {
-			String var_name = "n_out" + itos(node) + "p" + itos(i);
-			switch (vsnode->get_output_port_type(i)) {
-				case VisualShaderNode::PORT_TYPE_SCALAR:
-					outputs[i] = "float " + var_name;
-					break;
-				case VisualShaderNode::PORT_TYPE_VECTOR:
-					outputs[i] = "vec3 " + var_name;
-					break;
-				case VisualShaderNode::PORT_TYPE_BOOLEAN:
-					outputs[i] = "bool " + var_name;
-					break;
-				case VisualShaderNode::PORT_TYPE_TRANSFORM:
-					outputs[i] = "mat4 " + var_name;
-					break;
-				default: {
-				}
-			}
-		}
-
-	} else {
-		for (int i = 0; i < output_count; i++) {
-			outputs[i] = "n_out" + itos(node) + "p" + itos(i);
-			switch (vsnode->get_output_port_type(i)) {
-				case VisualShaderNode::PORT_TYPE_SCALAR:
-					code += String() + "\tfloat " + outputs[i] + ";\n";
-					break;
-				case VisualShaderNode::PORT_TYPE_VECTOR:
-					code += String() + "\tvec3 " + outputs[i] + ";\n";
-					break;
-				case VisualShaderNode::PORT_TYPE_BOOLEAN:
-					code += String() + "\tbool " + outputs[i] + ";\n";
-					break;
-				case VisualShaderNode::PORT_TYPE_TRANSFORM:
-					code += String() + "\tmat4 " + outputs[i] + ";\n";
-					break;
-				default: {
-				}
-			}
-		}
-	}
-
-	code += vsnode->generate_code(get_mode(), type, node, inputs, outputs, for_preview);
-
-	code += "\n"; //
-	processed.insert(node);
-
-	return OK;
-}
-
-void VisualShader::_update_shader() const {
-	if (!dirty.is_set()) {
-		return;
-	}
-
-	dirty.clear();
-
-	StringBuilder global_code;
-	StringBuilder global_code_per_node;
-	Map<Type, StringBuilder> global_code_per_func;
-	StringBuilder code;
-	Vector<VisualShader::DefaultTextureParam> default_tex_params;
-	Set<StringName> classes;
-	List<int> insertion_pos;
-	static const char *shader_mode_str[Shader::MODE_MAX] = { "spatial", "canvas_item", "particles" };
-
-	global_code += String() + "shader_type " + shader_mode_str[shader_mode] + ";\n";
-
-	String render_mode;
-
-	{
-		//fill render mode enums
-		int idx = 0;
-		bool specular = false;
-		while (render_mode_enums[idx].string) {
-			if (shader_mode == render_mode_enums[idx].mode) {
-				if (shader_mode == Shader::MODE_SPATIAL) {
-					if (String(render_mode_enums[idx].string) == "specular") {
-						specular = true;
-					}
-				}
-				if (modes.has(render_mode_enums[idx].string) || specular) {
-					int which = 0;
-					if (modes.has(render_mode_enums[idx].string)) {
-						which = modes[render_mode_enums[idx].string];
-					}
-					int count = 0;
-					for (int i = 0; i < ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode)).size(); i++) {
-						String mode = ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode))[i];
-						if (mode.begins_with(render_mode_enums[idx].string)) {
-							if (count == which) {
-								if (render_mode != String()) {
-									render_mode += ", ";
-								}
-								render_mode += mode;
-								break;
-							}
-							count++;
-						}
-					}
-				}
-			}
-			idx++;
-		}
-
-		//fill render mode flags
-		for (int i = 0; i < ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode)).size(); i++) {
-			String mode = ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader_mode))[i];
-			if (flags.has(mode)) {
-				if (render_mode != String()) {
-					render_mode += ", ";
-				}
-				render_mode += mode;
-			}
-		}
-	}
-
-	if (render_mode != String()) {
-		global_code += "render_mode " + render_mode + ";\n\n";
-	}
-
-	static const char *func_name[TYPE_MAX] = { "vertex", "fragment", "light" };
-
-	String global_expressions;
-	Set<String> used_uniform_names;
-	List<VisualShaderNodeUniform *> uniforms;
-
-	for (int i = 0, index = 0; i < TYPE_MAX; i++) {
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			Ref<VisualShaderNodeGlobalExpression> global_expression = Object::cast_to<VisualShaderNodeGlobalExpression>(E->get().node.ptr());
-			if (global_expression.is_valid()) {
-				String expr = "";
-				expr += "// " + global_expression->get_caption() + ":" + itos(index++) + "\n";
-				expr += global_expression->generate_global(get_mode(), Type(i), -1);
-				expr = expr.replace("\n", "\n\t");
-				expr += "\n";
-				global_expressions += expr;
-			}
-			Ref<VisualShaderNodeUniformRef> uniform_ref = Object::cast_to<VisualShaderNodeUniformRef>(E->get().node.ptr());
-			if (uniform_ref.is_valid()) {
-				used_uniform_names.insert(uniform_ref->get_uniform_name());
-			}
-			Ref<VisualShaderNodeUniform> uniform = Object::cast_to<VisualShaderNodeUniform>(E->get().node.ptr());
-			if (uniform.is_valid()) {
-				uniforms.push_back(uniform.ptr());
-			}
-		}
-	}
-
-	for (int i = 0; i < uniforms.size(); i++) {
-		VisualShaderNodeUniform *uniform = uniforms[i];
-		if (used_uniform_names.has(uniform->get_uniform_name())) {
-			global_code += uniform->generate_global(get_mode(), Type(i), -1);
-			const_cast<VisualShaderNodeUniform *>(uniform)->set_global_code_generated(true);
-		} else {
-			const_cast<VisualShaderNodeUniform *>(uniform)->set_global_code_generated(false);
-		}
-	}
-
-	for (int i = 0; i < TYPE_MAX; i++) {
-		//make it faster to go around through shader
-		VMap<ConnectionKey, const List<Connection>::Element *> input_connections;
-		VMap<ConnectionKey, const List<Connection>::Element *> output_connections;
-
-		for (const List<Connection>::Element *E = graph[i].connections.front(); E; E = E->next()) {
-			ConnectionKey from_key;
-			from_key.node = E->get().from_node;
-			from_key.port = E->get().from_port;
-
-			output_connections.insert(from_key, E);
-
-			ConnectionKey to_key;
-			to_key.node = E->get().to_node;
-			to_key.port = E->get().to_port;
-
-			input_connections.insert(to_key, E);
-		}
-
-		code += "\nvoid " + String(func_name[i]) + "() {\n";
-
-		Set<int> processed;
-		Error err = _write_node(Type(i), global_code, global_code_per_node, global_code_per_func, code, default_tex_params, input_connections, output_connections, NODE_ID_OUTPUT, processed, false, classes);
-		ERR_FAIL_COND(err != OK);
-		insertion_pos.push_back(code.get_string_length());
-
-		code += "}\n";
-	}
-
-	//set code secretly
-	global_code += "\n\n";
-	String final_code = global_code;
-	final_code += global_code_per_node;
-	final_code += global_expressions;
-	String tcode = code;
-	for (int i = 0; i < TYPE_MAX; i++) {
-		tcode = tcode.insert(insertion_pos[i], global_code_per_func[Type(i)]);
-	}
-	final_code += tcode;
-
-	const_cast<VisualShader *>(this)->set_code(final_code);
-	for (int i = 0; i < default_tex_params.size(); i++) {
-		const_cast<VisualShader *>(this)->set_default_texture_param(default_tex_params[i].name, default_tex_params[i].param);
-	}
-	if (previous_code != final_code) {
-		const_cast<VisualShader *>(this)->emit_signal("changed");
-	}
-	previous_code = final_code;
-}
-
-void VisualShader::_queue_update() {
-	if (dirty.is_set()) {
-		return;
-	}
-
-	dirty.set();
-	call_deferred("_update_shader");
-}
-
-void VisualShader::_input_type_changed(Type p_type, int p_id) {
-	ERR_FAIL_INDEX(p_type, TYPE_MAX);
-	//erase connections using this input, as type changed
-	Graph *g = &graph[p_type];
-
-	for (List<Connection>::Element *E = g->connections.front(); E;) {
-		List<Connection>::Element *N = E->next();
-		if (E->get().from_node == p_id) {
-			g->connections.erase(E);
-			g->nodes[E->get().to_node].prev_connected_nodes.erase(p_id);
-		}
-		E = N;
-	}
-}
-
-void VisualShader::rebuild() {
-	dirty.set();
-	_update_shader();
-}
-
-void VisualShader::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_mode", "mode"), &VisualShader::set_mode);
-
-	ClassDB::bind_method(D_METHOD("add_node", "type", "node", "position", "id"), &VisualShader::add_node);
-	ClassDB::bind_method(D_METHOD("get_node", "type", "id"), &VisualShader::get_node);
-
-	ClassDB::bind_method(D_METHOD("set_node_position", "type", "id", "position"), &VisualShader::set_node_position);
-	ClassDB::bind_method(D_METHOD("get_node_position", "type", "id"), &VisualShader::get_node_position);
-
-	ClassDB::bind_method(D_METHOD("get_node_list", "type"), &VisualShader::get_node_list);
-	ClassDB::bind_method(D_METHOD("get_valid_node_id", "type"), &VisualShader::get_valid_node_id);
-
-	ClassDB::bind_method(D_METHOD("remove_node", "type", "id"), &VisualShader::remove_node);
-
-	ClassDB::bind_method(D_METHOD("is_node_connection", "type", "from_node", "from_port", "to_node", "to_port"), &VisualShader::is_node_connection);
-	ClassDB::bind_method(D_METHOD("can_connect_nodes", "type", "from_node", "from_port", "to_node", "to_port"), &VisualShader::is_node_connection);
-
-	ClassDB::bind_method(D_METHOD("connect_nodes", "type", "from_node", "from_port", "to_node", "to_port"), &VisualShader::connect_nodes);
-	ClassDB::bind_method(D_METHOD("disconnect_nodes", "type", "from_node", "from_port", "to_node", "to_port"), &VisualShader::disconnect_nodes);
-	ClassDB::bind_method(D_METHOD("connect_nodes_forced", "type", "from_node", "from_port", "to_node", "to_port"), &VisualShader::connect_nodes_forced);
-
-	ClassDB::bind_method(D_METHOD("get_node_connections", "type"), &VisualShader::_get_node_connections);
-
-	ClassDB::bind_method(D_METHOD("set_graph_offset", "offset"), &VisualShader::set_graph_offset);
-	ClassDB::bind_method(D_METHOD("get_graph_offset"), &VisualShader::get_graph_offset);
-
-	ClassDB::bind_method(D_METHOD("_queue_update"), &VisualShader::_queue_update);
-	ClassDB::bind_method(D_METHOD("_update_shader"), &VisualShader::_update_shader);
-
-	ClassDB::bind_method(D_METHOD("_input_type_changed"), &VisualShader::_input_type_changed);
-
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_graph_offset", "get_graph_offset");
-
-	ADD_PROPERTY_DEFAULT("code", ""); // Inherited from Shader, prevents showing default code as override in docs.
-
-	BIND_ENUM_CONSTANT(TYPE_VERTEX);
-	BIND_ENUM_CONSTANT(TYPE_FRAGMENT);
-	BIND_ENUM_CONSTANT(TYPE_LIGHT);
-	BIND_ENUM_CONSTANT(TYPE_MAX);
-
-	BIND_CONSTANT(NODE_ID_INVALID);
-	BIND_CONSTANT(NODE_ID_OUTPUT);
-}
-
-VisualShader::VisualShader() {
-	shader_mode = Shader::MODE_SPATIAL;
-
-	for (int i = 0; i < TYPE_MAX; i++) {
-		Ref<VisualShaderNodeOutput> output;
-		output.instance();
-		output->shader_type = Type(i);
-		output->shader_mode = shader_mode;
-		graph[i].nodes[NODE_ID_OUTPUT].node = output;
-		graph[i].nodes[NODE_ID_OUTPUT].position = Vector2(400, 150);
-	}
-
-	dirty.set();
-}
-
-///////////////////////////////////////////////////////////
-
-const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = {
-	// Spatial, Vertex
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "VERTEX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "tangent", "TANGENT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "binormal", "BINORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv2", "vec3(UV2, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "point_size", "POINT_SIZE" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "modelview", "MODELVIEW_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "camera", "CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_camera", "INV_CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "projection", "PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_projection", "INV_PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "viewport_size", "vec3(VIEWPORT_SIZE, 0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
-
-	// Spatial, Fragment
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "VERTEX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "tangent", "TANGENT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "binormal", "BINORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "view", "VIEW" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv2", "vec3(UV2, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "point_coord", "vec3(POINT_COORD, 0.0)" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "side", "float(FRONT_FACING ? 1.0 : 0.0)" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_camera", "INV_CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_TRANSFORM, "camera", "CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_TRANSFORM, "projection", "PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_projection", "INV_PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "viewport_size", "vec3(VIEWPORT_SIZE, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_BOOLEAN, "front_facing", "FRONT_FACING" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "screen_texture", "SCREEN_TEXTURE" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "depth_texture", "DEPTH_TEXTURE" },
-
-	// Spatial, Light
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "view", "VIEW" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light", "LIGHT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light_color", "LIGHT_COLOR" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "attenuation", "ATTENUATION" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "albedo", "ALBEDO" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "transmission", "TRANSMISSION" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "diffuse", "DIFFUSE_LIGHT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "specular", "SPECULAR_LIGHT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "roughness", "ROUGHNESS" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "metallic", "METALLIC" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_camera", "INV_CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_TRANSFORM, "camera", "CAMERA_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_TRANSFORM, "projection", "PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_projection", "INV_PROJECTION_MATRIX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "viewport_size", "vec3(VIEWPORT_SIZE, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
-	// Canvas Item, Vertex
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "vec3(VERTEX, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV,0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "modulate_color", "MODULATE.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "modulate_alpha", "MODULATE.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "point_size", "POINT_SIZE" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "texture_pixel_size", "vec3(TEXTURE_PIXEL_SIZE, 1.0)" },
-
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "projection", "PROJECTION_MATRIX" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "extra", "EXTRA_MATRIX" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "light_pass", "float(AT_LIGHT_PASS ? 1.0 : 0.0)" },
-	// Canvas Item, Fragment
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "modulate_color", "MODULATE.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "modulate_alpha", "MODULATE.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "texture_pixel_size", "vec3(TEXTURE_PIXEL_SIZE, 1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_pixel_size", "vec3(SCREEN_PIXEL_SIZE, 1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "point_coord", "vec3(POINT_COORD, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "light_pass", "float(AT_LIGHT_PASS ? 1.0 : 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "texture", "TEXTURE" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "normal_texture", "NORMAL_TEXTURE" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "screen_texture", "SCREEN_TEXTURE" },
-	// Canvas Item, Light
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "modulate_color", "MODULATE.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "modulate_alpha", "MODULATE.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light_vec", "vec3(LIGHT_VEC, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "light_height", "LIGHT_HEIGHT" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light_color", "LIGHT_COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "light_alpha", "LIGHT_COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light_uv", "vec3(LIGHT_UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "shadow_color", "SHADOW_COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "shadow_alpha", "SHADOW_COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "shadow_vec", "vec3(SHADOW_VEC, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "texture_pixel_size", "vec3(TEXTURE_PIXEL_SIZE, 1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "point_coord", "vec3(POINT_COORD, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SAMPLER, "texture", "TEXTURE" },
-
-	// Particles, Vertex
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "velocity", "VELOCITY" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "restart", "float(RESTART ? 1.0 : 0.0)" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "active", "float(ACTIVE ? 1.0 : 0.0)" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "custom", "CUSTOM.rgb" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "custom_alpha", "CUSTOM.a" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "transform", "TRANSFORM" },
-
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "delta", "DELTA" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "lifetime", "LIFETIME" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "index", "float(INDEX)" },
-
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "emission_transform", "EMISSION_TRANSFORM" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
-};
-
-const VisualShaderNodeInput::Port VisualShaderNodeInput::preview_ports[] = {
-
-	// Spatial, Fragment
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "tangent", "vec3(0.0, 1.0, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "binormal", "vec3(1.0, 0.0, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv2", "vec3(UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "side", "1.0" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "viewport_size", "vec3(1.0,1.0, 0.0)" },
-
-	// Spatial, Light
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "viewport_size", "vec3(1.0, 1.0, 0.0)" },
-	// Canvas Item, Vertex
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "vec3(VERTEX, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	// Canvas Item, Fragment
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	// Canvas Item, Light
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "vec3(UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
-
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "screen_uv", "vec3(SCREEN_UV, 0.0)" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	// Particles, Vertex
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "velocity", "vec3(0.0, 0.0, 1.0)" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
-	{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
-};
-
-int VisualShaderNodeInput::get_input_port_count() const {
-	return 0;
-}
-VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-String VisualShaderNodeInput::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeInput::get_output_port_count() const {
-	return 1;
-}
-VisualShaderNodeInput::PortType VisualShaderNodeInput::get_output_port_type(int p_port) const {
-	return get_input_type_by_name(input_name);
-}
-String VisualShaderNodeInput::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeInput::get_caption() const {
-	return "Input";
-}
-
-String VisualShaderNodeInput::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	if (get_output_port_type(0) == PORT_TYPE_SAMPLER) {
-		return "";
-	}
-
-	if (p_for_preview) {
-		int idx = 0;
-
-		String code;
-
-		while (preview_ports[idx].mode != Shader::MODE_MAX) {
-			if (preview_ports[idx].mode == shader_mode && preview_ports[idx].shader_type == shader_type && preview_ports[idx].name == input_name) {
-				code = "\t" + p_output_vars[0] + " = " + preview_ports[idx].string + ";\n";
-				break;
-			}
-			idx++;
-		}
-
-		if (code == String()) {
-			switch (get_output_port_type(0)) {
-				case PORT_TYPE_SCALAR: {
-					code = "\t" + p_output_vars[0] + " = 0.0;\n";
-				} break; //default (none found) is scalar
-				case PORT_TYPE_VECTOR: {
-					code = "\t" + p_output_vars[0] + " = vec3(0.0);\n";
-				} break; //default (none found) is scalar
-				case PORT_TYPE_TRANSFORM: {
-					code = "\t" + p_output_vars[0] + " = mat4( vec4(1.0,0.0,0.0,0.0), vec4(0.0,1.0,0.0,0.0), vec4(0.0,0.0,1.0,0.0), vec4(0.0,0.0,0.0,1.0) );\n";
-				} break; //default (none found) is scalar
-				case PORT_TYPE_BOOLEAN: {
-					code = "\t" + p_output_vars[0] + " = false;\n";
-				} break;
-				default:
-					break;
-			}
-		}
-
-		return code;
-
-	} else {
-		int idx = 0;
-
-		String code;
-
-		while (ports[idx].mode != Shader::MODE_MAX) {
-			if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type && ports[idx].name == input_name) {
-				code = "\t" + p_output_vars[0] + " = " + ports[idx].string + ";\n";
-				break;
-			}
-			idx++;
-		}
-
-		if (code == String()) {
-			code = "\t" + p_output_vars[0] + " = 0.0;\n"; //default (none found) is scalar
-		}
-
-		return code;
-	}
-}
-
-void VisualShaderNodeInput::set_input_name(String p_name) {
-	PortType prev_type = get_input_type_by_name(input_name);
-	input_name = p_name;
-	emit_changed();
-	if (get_input_type_by_name(input_name) != prev_type) {
-		emit_signal("input_type_changed");
-	}
-}
-
-String VisualShaderNodeInput::get_input_name() const {
-	return input_name;
-}
-
-String VisualShaderNodeInput::get_input_real_name() const {
-	int idx = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type && ports[idx].name == input_name) {
-			return String(ports[idx].string);
-		}
-		idx++;
-	}
-
-	return "";
-}
-
-VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_type_by_name(String p_name) const {
-	int idx = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type && ports[idx].name == p_name) {
-			return ports[idx].type;
-		}
-		idx++;
-	}
-
-	return PORT_TYPE_SCALAR;
-}
-
-int VisualShaderNodeInput::get_input_index_count() const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			count++;
-		}
-		idx++;
-	}
-
-	return count;
-}
-
-VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_index_type(int p_index) const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			if (count == p_index) {
-				return ports[idx].type;
-			}
-			count++;
-		}
-		idx++;
-	}
-
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeInput::get_input_index_name(int p_index) const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			if (count == p_index) {
-				return ports[idx].name;
-			}
-			count++;
-		}
-		idx++;
-	}
-
-	return "";
-}
-
-void VisualShaderNodeInput::_validate_property(PropertyInfo &property) const {
-	if (property.name == "input_name") {
-		String port_list;
-
-		int idx = 0;
-
-		while (ports[idx].mode != Shader::MODE_MAX) {
-			if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-				if (port_list != String()) {
-					port_list += ",";
-				}
-				port_list += ports[idx].name;
-			}
-			idx++;
-		}
-
-		if (port_list == "") {
-			port_list = TTR("None");
-		}
-		property.hint_string = port_list;
-	}
-}
-
-Vector<StringName> VisualShaderNodeInput::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("input_name");
-	return props;
-}
-
-void VisualShaderNodeInput::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_input_name", "name"), &VisualShaderNodeInput::set_input_name);
-	ClassDB::bind_method(D_METHOD("get_input_name"), &VisualShaderNodeInput::get_input_name);
-	ClassDB::bind_method(D_METHOD("get_input_real_name"), &VisualShaderNodeInput::get_input_real_name);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "input_name", PROPERTY_HINT_ENUM, ""), "set_input_name", "get_input_name");
-	ADD_SIGNAL(MethodInfo("input_type_changed"));
-}
-VisualShaderNodeInput::VisualShaderNodeInput() {
-	input_name = "[None]";
-	// changed when set
-	shader_type = VisualShader::TYPE_MAX;
-	shader_mode = Shader::MODE_MAX;
-}
-
-////////////// UniformRef
-
-List<VisualShaderNodeUniformRef::Uniform> uniforms;
-
-void VisualShaderNodeUniformRef::add_uniform(const String &p_name, UniformType p_type) {
-	uniforms.push_back({ p_name, p_type });
-}
-
-void VisualShaderNodeUniformRef::clear_uniforms() {
-	uniforms.clear();
-}
-
-String VisualShaderNodeUniformRef::get_caption() const {
-	return "UniformRef";
-}
-
-int VisualShaderNodeUniformRef::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_input_port_type(int p_port) const {
-	return PortType::PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeUniformRef::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeUniformRef::get_output_port_count() const {
-	switch (uniform_type) {
-		case UniformType::UNIFORM_TYPE_SCALAR:
-			return 1;
-		case UniformType::UNIFORM_TYPE_BOOLEAN:
-			return 1;
-		case UniformType::UNIFORM_TYPE_VECTOR:
-			return 1;
-		case UniformType::UNIFORM_TYPE_TRANSFORM:
-			return 1;
-		case UniformType::UNIFORM_TYPE_COLOR:
-			return 2;
-		case UniformType::UNIFORM_TYPE_SAMPLER:
-			return 1;
-		default:
-			break;
-	}
-	return 0;
-}
-
-VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_output_port_type(int p_port) const {
-	switch (uniform_type) {
-		case UniformType::UNIFORM_TYPE_SCALAR:
-			return PortType::PORT_TYPE_SCALAR;
-		case UniformType::UNIFORM_TYPE_BOOLEAN:
-			return PortType::PORT_TYPE_BOOLEAN;
-		case UniformType::UNIFORM_TYPE_VECTOR:
-			return PortType::PORT_TYPE_VECTOR;
-		case UniformType::UNIFORM_TYPE_TRANSFORM:
-			return PortType::PORT_TYPE_TRANSFORM;
-		case UniformType::UNIFORM_TYPE_COLOR:
-			if (p_port == 0) {
-				return PortType::PORT_TYPE_VECTOR;
-			} else if (p_port == 1) {
-				return PORT_TYPE_SCALAR;
-			}
-			break;
-		case UniformType::UNIFORM_TYPE_SAMPLER:
-			return PortType::PORT_TYPE_SAMPLER;
-		default:
-			break;
-	}
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeUniformRef::get_output_port_name(int p_port) const {
-	switch (uniform_type) {
-		case UniformType::UNIFORM_TYPE_SCALAR:
-			return "";
-		case UniformType::UNIFORM_TYPE_BOOLEAN:
-			return "";
-		case UniformType::UNIFORM_TYPE_VECTOR:
-			return "";
-		case UniformType::UNIFORM_TYPE_TRANSFORM:
-			return "";
-		case UniformType::UNIFORM_TYPE_COLOR:
-			if (p_port == 0) {
-				return "rgb";
-			} else if (p_port == 1) {
-				return "alpha";
-			}
-			break;
-		case UniformType::UNIFORM_TYPE_SAMPLER:
-			return "";
-			break;
-		default:
-			break;
-	}
-	return "";
-}
-
-void VisualShaderNodeUniformRef::set_uniform_name(const String &p_name) {
-	uniform_name = p_name;
-	if (p_name != "[None]") {
-		uniform_type = get_uniform_type_by_name(p_name);
-	} else {
-		uniform_type = UniformType::UNIFORM_TYPE_SCALAR;
-	}
-	emit_changed();
-}
-
-String VisualShaderNodeUniformRef::get_uniform_name() const {
-	return uniform_name;
-}
-
-int VisualShaderNodeUniformRef::get_uniforms_count() const {
-	return uniforms.size();
-}
-
-String VisualShaderNodeUniformRef::get_uniform_name_by_index(int p_idx) const {
-	if (p_idx >= 0 && p_idx < uniforms.size()) {
-		return uniforms[p_idx].name;
-	}
-	return "";
-}
-
-VisualShaderNodeUniformRef::UniformType VisualShaderNodeUniformRef::get_uniform_type_by_name(const String &p_name) const {
-	for (int i = 0; i < uniforms.size(); i++) {
-		if (uniforms[i].name == p_name) {
-			return uniforms[i].type;
-		}
-	}
-	return UniformType::UNIFORM_TYPE_SCALAR;
-}
-
-VisualShaderNodeUniformRef::UniformType VisualShaderNodeUniformRef::get_uniform_type_by_index(int p_idx) const {
-	if (p_idx >= 0 && p_idx < uniforms.size()) {
-		return uniforms[p_idx].type;
-	}
-	return UniformType::UNIFORM_TYPE_SCALAR;
-}
-
-String VisualShaderNodeUniformRef::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	switch (uniform_type) {
-		case UniformType::UNIFORM_TYPE_SCALAR:
-			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-		case UniformType::UNIFORM_TYPE_BOOLEAN:
-			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-		case UniformType::UNIFORM_TYPE_VECTOR:
-			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-		case UniformType::UNIFORM_TYPE_TRANSFORM:
-			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-		case UniformType::UNIFORM_TYPE_COLOR: {
-			String code = "\t" + p_output_vars[0] + " = " + get_uniform_name() + ".rgb;\n";
-			code += "\t" + p_output_vars[1] + " = " + get_uniform_name() + ".a;\n";
-			return code;
-		} break;
-		case UniformType::UNIFORM_TYPE_SAMPLER:
-			break;
-		default:
-			break;
-	}
-	return "";
-}
-
-void VisualShaderNodeUniformRef::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_uniform_name", "name"), &VisualShaderNodeUniformRef::set_uniform_name);
-	ClassDB::bind_method(D_METHOD("get_uniform_name"), &VisualShaderNodeUniformRef::get_uniform_name);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "uniform_name", PROPERTY_HINT_ENUM, ""), "set_uniform_name", "get_uniform_name");
-}
-
-Vector<StringName> VisualShaderNodeUniformRef::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("uniform_name");
-	return props;
-}
-
-VisualShaderNodeUniformRef::VisualShaderNodeUniformRef() {
-	uniform_name = "[None]";
-	uniform_type = UniformType::UNIFORM_TYPE_SCALAR;
-}
-
-////////////////////////////////////////////
-
-const VisualShaderNodeOutput::Port VisualShaderNodeOutput::ports[] = {
-	// Spatial, Vertex
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "VERTEX" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "tangent", "TANGENT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "binormal", "BINORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "UV:xy" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv2", "UV2:xy" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "roughness", "ROUGHNESS" },
-	// Spatial, Fragment
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "albedo", "ALBEDO" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "ALPHA" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "metallic", "METALLIC" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "roughness", "ROUGHNESS" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "specular", "SPECULAR" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "emission", "EMISSION" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "ao", "AO" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normalmap", "NORMALMAP" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "normalmap_depth", "NORMALMAP_DEPTH" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "rim", "RIM" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "rim_tint", "RIM_TINT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "clearcoat", "CLEARCOAT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "clearcoat_gloss", "CLEARCOAT_GLOSS" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "anisotropy", "ANISOTROPY" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "anisotropy_flow", "ANISOTROPY_FLOW:xy" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "subsurf_scatter", "SSS_STRENGTH" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "transmission", "TRANSMISSION" },
-
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha_scissor", "ALPHA_SCISSOR" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "ao_light_affect", "AO_LIGHT_AFFECT" },
-
-	// Spatial, Light
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "diffuse", "DIFFUSE_LIGHT" },
-	{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "specular", "SPECULAR_LIGHT" },
-	// Canvas Item, Vertex
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "vertex", "VERTEX:xy" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "uv", "UV:xy" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	// Canvas Item, Fragment
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normalmap", "NORMALMAP" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "normalmap_depth", "NORMALMAP_DEPTH" },
-	// Canvas Item, Light
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light", "LIGHT.rgb" },
-	{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "light_alpha", "LIGHT.a" },
-	// Particles, Vertex
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR.rgb" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "COLOR.a" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "velocity", "VELOCITY" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "custom", "CUSTOM.rgb" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "custom_alpha", "CUSTOM.a" },
-	{ Shader::MODE_PARTICLES, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "transform", "TRANSFORM" },
-	{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
-};
-
-int VisualShaderNodeOutput::get_input_port_count() const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			count++;
-		}
-		idx++;
-	}
-
-	return count;
-}
-
-VisualShaderNodeOutput::PortType VisualShaderNodeOutput::get_input_port_type(int p_port) const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			if (count == p_port) {
-				return ports[idx].type;
-			}
-			count++;
-		}
-		idx++;
-	}
-
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeOutput::get_input_port_name(int p_port) const {
-	int idx = 0;
-	int count = 0;
-
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			if (count == p_port) {
-				return String(ports[idx].name).capitalize();
-			}
-			count++;
-		}
-		idx++;
-	}
-
-	return String();
-}
-
-Variant VisualShaderNodeOutput::get_input_port_default_value(int p_port) const {
-	return Variant();
-}
-
-int VisualShaderNodeOutput::get_output_port_count() const {
-	return 0;
-}
-VisualShaderNodeOutput::PortType VisualShaderNodeOutput::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-String VisualShaderNodeOutput::get_output_port_name(int p_port) const {
-	return String();
-}
-
-bool VisualShaderNodeOutput::is_port_separator(int p_index) const {
-	if (shader_mode == Shader::MODE_SPATIAL && shader_type == VisualShader::TYPE_FRAGMENT) {
-		String name = get_input_port_name(p_index);
-		return (name == "Normal" || name == "Rim" || name == "Alpha Scissor");
-	}
-	return false;
-}
-
-String VisualShaderNodeOutput::get_caption() const {
-	return "Output";
-}
-
-String VisualShaderNodeOutput::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	int idx = 0;
-	int count = 0;
-
-	String code;
-	while (ports[idx].mode != Shader::MODE_MAX) {
-		if (ports[idx].mode == shader_mode && ports[idx].shader_type == shader_type) {
-			if (p_input_vars[count] != String()) {
-				String s = ports[idx].string;
-				if (s.find(":") != -1) {
-					code += "\t" + s.get_slicec(':', 0) + " = " + p_input_vars[count] + "." + s.get_slicec(':', 1) + ";\n";
-				} else {
-					code += "\t" + s + " = " + p_input_vars[count] + ";\n";
-				}
-			}
-			count++;
-		}
-		idx++;
-	}
-
-	return code;
-}
-
-VisualShaderNodeOutput::VisualShaderNodeOutput() {
-}
-
-///////////////////////////
-
-void VisualShaderNodeUniform::set_uniform_name(const String &p_name) {
-	uniform_name = p_name;
-	emit_signal("name_changed");
-	emit_changed();
-}
-
-String VisualShaderNodeUniform::get_uniform_name() const {
-	return uniform_name;
-}
-
-void VisualShaderNodeUniform::set_global_code_generated(bool p_enabled) {
-	global_code_generated = p_enabled;
-}
-
-bool VisualShaderNodeUniform::is_global_code_generated() const {
-	return global_code_generated;
-}
-
-void VisualShaderNodeUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_uniform_name", "name"), &VisualShaderNodeUniform::set_uniform_name);
-	ClassDB::bind_method(D_METHOD("get_uniform_name"), &VisualShaderNodeUniform::get_uniform_name);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "uniform_name"), "set_uniform_name", "get_uniform_name");
-}
-
-bool VisualShaderNodeUniform::is_show_prop_names() const {
-	return true;
-}
-
-VisualShaderNodeUniform::VisualShaderNodeUniform() {
-}
-
-////////////// GroupBase
-
-String VisualShaderNodeGroupBase::get_caption() const {
-	return "Group";
-}
-
-void VisualShaderNodeGroupBase::set_size(const Vector2 &p_size) {
-	size = p_size;
-}
-
-Vector2 VisualShaderNodeGroupBase::get_size() const {
-	return size;
-}
-
-void VisualShaderNodeGroupBase::set_inputs(const String &p_inputs) {
-	if (inputs == p_inputs) {
-		return;
-	}
-
-	clear_input_ports();
-
-	inputs = p_inputs;
-
-	Vector<String> input_strings = inputs.split(";", false);
-
-	int input_port_count = input_strings.size();
-
-	for (int i = 0; i < input_port_count; i++) {
-		Vector<String> arr = input_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		int port_idx = arr[0].to_int();
-		int port_type = arr[1].to_int();
-		String port_name = arr[2];
-
-		Port port;
-		port.type = (PortType)port_type;
-		port.name = port_name;
-		input_ports[port_idx] = port;
-	}
-}
-
-String VisualShaderNodeGroupBase::get_inputs() const {
-	return inputs;
-}
-
-void VisualShaderNodeGroupBase::set_outputs(const String &p_outputs) {
-	if (outputs == p_outputs) {
-		return;
-	}
-
-	clear_output_ports();
-
-	outputs = p_outputs;
-
-	Vector<String> output_strings = outputs.split(";", false);
-
-	int output_port_count = output_strings.size();
-
-	for (int i = 0; i < output_port_count; i++) {
-		Vector<String> arr = output_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		int port_idx = arr[0].to_int();
-		int port_type = arr[1].to_int();
-		String port_name = arr[2];
-
-		Port port;
-		port.type = (PortType)port_type;
-		port.name = port_name;
-		output_ports[port_idx] = port;
-	}
-}
-
-String VisualShaderNodeGroupBase::get_outputs() const {
-	return outputs;
-}
-
-bool VisualShaderNodeGroupBase::is_valid_port_name(const String &p_name) const {
-	if (!p_name.is_valid_identifier()) {
-		return false;
-	}
-	for (int i = 0; i < get_input_port_count(); i++) {
-		if (get_input_port_name(i) == p_name) {
-			return false;
-		}
-	}
-	for (int i = 0; i < get_output_port_count(); i++) {
-		if (get_output_port_name(i) == p_name) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void VisualShaderNodeGroupBase::add_input_port(int p_id, int p_type, const String &p_name) {
-	String str = itos(p_id) + "," + itos(p_type) + "," + p_name + ";";
-	Vector<String> inputs_strings = inputs.split(";", false);
-	int index = 0;
-	if (p_id < inputs_strings.size()) {
-		for (int i = 0; i < inputs_strings.size(); i++) {
-			if (i == p_id) {
-				inputs = inputs.insert(index, str);
-				break;
-			}
-			index += inputs_strings[i].size();
-		}
-	} else {
-		inputs += str;
-	}
-
-	inputs_strings = inputs.split(";", false);
-	index = 0;
-
-	for (int i = 0; i < inputs_strings.size(); i++) {
-		int count = 0;
-		for (int j = 0; j < inputs_strings[i].size(); j++) {
-			if (inputs_strings[i][j] == ',') {
-				break;
-			}
-			count++;
-		}
-
-		inputs.erase(index, count);
-		inputs = inputs.insert(index, itos(i));
-		index += inputs_strings[i].size();
-	}
-
-	_apply_port_changes();
-}
-
-void VisualShaderNodeGroupBase::remove_input_port(int p_id) {
-	ERR_FAIL_COND(!has_input_port(p_id));
-
-	Vector<String> inputs_strings = inputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < inputs_strings.size(); i++) {
-		Vector<String> arr = inputs_strings[i].split(",");
-		if (arr[0].to_int() == p_id) {
-			count = inputs_strings[i].size();
-			break;
-		}
-		index += inputs_strings[i].size();
-	}
-	inputs.erase(index, count);
-
-	inputs_strings = inputs.split(";", false);
-	for (int i = p_id; i < inputs_strings.size(); i++) {
-		inputs = inputs.replace_first(inputs_strings[i].split(",")[0], itos(i));
-	}
-
-	_apply_port_changes();
-}
-
-int VisualShaderNodeGroupBase::get_input_port_count() const {
-	return input_ports.size();
-}
-
-bool VisualShaderNodeGroupBase::has_input_port(int p_id) const {
-	return input_ports.has(p_id);
-}
-
-void VisualShaderNodeGroupBase::add_output_port(int p_id, int p_type, const String &p_name) {
-	String str = itos(p_id) + "," + itos(p_type) + "," + p_name + ";";
-	Vector<String> outputs_strings = outputs.split(";", false);
-	int index = 0;
-	if (p_id < outputs_strings.size()) {
-		for (int i = 0; i < outputs_strings.size(); i++) {
-			if (i == p_id) {
-				outputs = outputs.insert(index, str);
-				break;
-			}
-			index += outputs_strings[i].size();
-		}
-	} else {
-		outputs += str;
-	}
-
-	outputs_strings = outputs.split(";", false);
-	index = 0;
-
-	for (int i = 0; i < outputs_strings.size(); i++) {
-		int count = 0;
-		for (int j = 0; j < outputs_strings[i].size(); j++) {
-			if (outputs_strings[i][j] == ',') {
-				break;
-			}
-			count++;
-		}
-
-		outputs.erase(index, count);
-		outputs = outputs.insert(index, itos(i));
-		index += outputs_strings[i].size();
-	}
-
-	_apply_port_changes();
-}
-
-void VisualShaderNodeGroupBase::remove_output_port(int p_id) {
-	ERR_FAIL_COND(!has_output_port(p_id));
-
-	Vector<String> outputs_strings = outputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < outputs_strings.size(); i++) {
-		Vector<String> arr = outputs_strings[i].split(",");
-		if (arr[0].to_int() == p_id) {
-			count = outputs_strings[i].size();
-			break;
-		}
-		index += outputs_strings[i].size();
-	}
-	outputs.erase(index, count);
-
-	outputs_strings = outputs.split(";", false);
-	for (int i = p_id; i < outputs_strings.size(); i++) {
-		outputs = outputs.replace_first(outputs_strings[i].split(",")[0], itos(i));
-	}
-
-	_apply_port_changes();
-}
-
-int VisualShaderNodeGroupBase::get_output_port_count() const {
-	return output_ports.size();
-}
-
-bool VisualShaderNodeGroupBase::has_output_port(int p_id) const {
-	return output_ports.has(p_id);
-}
-
-void VisualShaderNodeGroupBase::clear_input_ports() {
-	input_ports.clear();
-}
-
-void VisualShaderNodeGroupBase::clear_output_ports() {
-	output_ports.clear();
-}
-
-void VisualShaderNodeGroupBase::set_input_port_type(int p_id, int p_type) {
-	ERR_FAIL_COND(!has_input_port(p_id));
-	ERR_FAIL_COND(p_type < 0 || p_type >= PORT_TYPE_MAX);
-
-	if (input_ports[p_id].type == p_type) {
-		return;
-	}
-
-	Vector<String> inputs_strings = inputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < inputs_strings.size(); i++) {
-		Vector<String> arr = inputs_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		if (arr[0].to_int() == p_id) {
-			index += arr[0].size();
-			count = arr[1].size() - 1;
-			break;
-		}
-		index += inputs_strings[i].size();
-	}
-
-	inputs.erase(index, count);
-
-	inputs = inputs.insert(index, itos(p_type));
-
-	_apply_port_changes();
-}
-
-VisualShaderNodeGroupBase::PortType VisualShaderNodeGroupBase::get_input_port_type(int p_id) const {
-	ERR_FAIL_COND_V(!input_ports.has(p_id), (PortType)0);
-	return input_ports[p_id].type;
-}
-
-void VisualShaderNodeGroupBase::set_input_port_name(int p_id, const String &p_name) {
-	ERR_FAIL_COND(!has_input_port(p_id));
-	ERR_FAIL_COND(!is_valid_port_name(p_name));
-
-	if (input_ports[p_id].name == p_name) {
-		return;
-	}
-
-	Vector<String> inputs_strings = inputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < inputs_strings.size(); i++) {
-		Vector<String> arr = inputs_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		if (arr[0].to_int() == p_id) {
-			index += arr[0].size() + arr[1].size();
-			count = arr[2].size() - 1;
-			break;
-		}
-		index += inputs_strings[i].size();
-	}
-
-	inputs.erase(index, count);
-
-	inputs = inputs.insert(index, p_name);
-
-	_apply_port_changes();
-}
-
-String VisualShaderNodeGroupBase::get_input_port_name(int p_id) const {
-	ERR_FAIL_COND_V(!input_ports.has(p_id), "");
-	return input_ports[p_id].name;
-}
-
-void VisualShaderNodeGroupBase::set_output_port_type(int p_id, int p_type) {
-	ERR_FAIL_COND(!has_output_port(p_id));
-	ERR_FAIL_COND(p_type < 0 || p_type >= PORT_TYPE_MAX);
-
-	if (output_ports[p_id].type == p_type) {
-		return;
-	}
-
-	Vector<String> output_strings = outputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < output_strings.size(); i++) {
-		Vector<String> arr = output_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		if (arr[0].to_int() == p_id) {
-			index += arr[0].size();
-			count = arr[1].size() - 1;
-			break;
-		}
-		index += output_strings[i].size();
-	}
-
-	outputs.erase(index, count);
-
-	outputs = outputs.insert(index, itos(p_type));
-
-	_apply_port_changes();
-}
-
-VisualShaderNodeGroupBase::PortType VisualShaderNodeGroupBase::get_output_port_type(int p_id) const {
-	ERR_FAIL_COND_V(!output_ports.has(p_id), (PortType)0);
-	return output_ports[p_id].type;
-}
-
-void VisualShaderNodeGroupBase::set_output_port_name(int p_id, const String &p_name) {
-	ERR_FAIL_COND(!has_output_port(p_id));
-	ERR_FAIL_COND(!is_valid_port_name(p_name));
-
-	if (output_ports[p_id].name == p_name) {
-		return;
-	}
-
-	Vector<String> output_strings = outputs.split(";", false);
-	int count = 0;
-	int index = 0;
-	for (int i = 0; i < output_strings.size(); i++) {
-		Vector<String> arr = output_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		if (arr[0].to_int() == p_id) {
-			index += arr[0].size() + arr[1].size();
-			count = arr[2].size() - 1;
-			break;
-		}
-		index += output_strings[i].size();
-	}
-
-	outputs.erase(index, count);
-
-	outputs = outputs.insert(index, p_name);
-
-	_apply_port_changes();
-}
-
-String VisualShaderNodeGroupBase::get_output_port_name(int p_id) const {
-	ERR_FAIL_COND_V(!output_ports.has(p_id), "");
-	return output_ports[p_id].name;
-}
-
-int VisualShaderNodeGroupBase::get_free_input_port_id() const {
-	return input_ports.size();
-}
-
-int VisualShaderNodeGroupBase::get_free_output_port_id() const {
-	return output_ports.size();
-}
-
-void VisualShaderNodeGroupBase::set_control(Control *p_control, int p_index) {
-	controls[p_index] = p_control;
-}
-
-Control *VisualShaderNodeGroupBase::get_control(int p_index) {
-	ERR_FAIL_COND_V(!controls.has(p_index), nullptr);
-	return controls[p_index];
-}
-
-void VisualShaderNodeGroupBase::_apply_port_changes() {
-	Vector<String> inputs_strings = inputs.split(";", false);
-	Vector<String> outputs_strings = outputs.split(";", false);
-
-	clear_input_ports();
-	clear_output_ports();
-
-	for (int i = 0; i < inputs_strings.size(); i++) {
-		Vector<String> arr = inputs_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		Port port;
-		port.type = (PortType)arr[1].to_int();
-		port.name = arr[2];
-		input_ports[i] = port;
-	}
-	for (int i = 0; i < outputs_strings.size(); i++) {
-		Vector<String> arr = outputs_strings[i].split(",");
-		ERR_FAIL_COND(arr.size() != 3);
-
-		Port port;
-		port.type = (PortType)arr[1].to_int();
-		port.name = arr[2];
-		output_ports[i] = port;
-	}
-}
-
-void VisualShaderNodeGroupBase::set_editable(bool p_enabled) {
-	editable = p_enabled;
-}
-
-bool VisualShaderNodeGroupBase::is_editable() const {
-	return editable;
-}
-
-void VisualShaderNodeGroupBase::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_size", "size"), &VisualShaderNodeGroupBase::set_size);
-	ClassDB::bind_method(D_METHOD("get_size"), &VisualShaderNodeGroupBase::get_size);
-
-	ClassDB::bind_method(D_METHOD("set_inputs", "inputs"), &VisualShaderNodeGroupBase::set_inputs);
-	ClassDB::bind_method(D_METHOD("get_inputs"), &VisualShaderNodeGroupBase::get_inputs);
-
-	ClassDB::bind_method(D_METHOD("set_outputs", "outputs"), &VisualShaderNodeGroupBase::set_outputs);
-	ClassDB::bind_method(D_METHOD("get_outputs"), &VisualShaderNodeGroupBase::get_outputs);
-
-	ClassDB::bind_method(D_METHOD("is_valid_port_name", "name"), &VisualShaderNodeGroupBase::is_valid_port_name);
-
-	ClassDB::bind_method(D_METHOD("add_input_port", "id", "type", "name"), &VisualShaderNodeGroupBase::add_input_port);
-	ClassDB::bind_method(D_METHOD("remove_input_port", "id"), &VisualShaderNodeGroupBase::remove_input_port);
-	ClassDB::bind_method(D_METHOD("get_input_port_count"), &VisualShaderNodeGroupBase::get_input_port_count);
-	ClassDB::bind_method(D_METHOD("has_input_port", "id"), &VisualShaderNodeGroupBase::has_input_port);
-	ClassDB::bind_method(D_METHOD("clear_input_ports"), &VisualShaderNodeGroupBase::clear_input_ports);
-
-	ClassDB::bind_method(D_METHOD("add_output_port", "id", "type", "name"), &VisualShaderNodeGroupBase::add_output_port);
-	ClassDB::bind_method(D_METHOD("remove_output_port", "id"), &VisualShaderNodeGroupBase::remove_output_port);
-	ClassDB::bind_method(D_METHOD("get_output_port_count"), &VisualShaderNodeGroupBase::get_output_port_count);
-	ClassDB::bind_method(D_METHOD("has_output_port", "id"), &VisualShaderNodeGroupBase::has_output_port);
-	ClassDB::bind_method(D_METHOD("clear_output_ports"), &VisualShaderNodeGroupBase::clear_output_ports);
-
-	ClassDB::bind_method(D_METHOD("set_input_port_name", "id", "name"), &VisualShaderNodeGroupBase::set_input_port_name);
-	ClassDB::bind_method(D_METHOD("set_input_port_type", "id", "type"), &VisualShaderNodeGroupBase::set_input_port_type);
-	ClassDB::bind_method(D_METHOD("set_output_port_name", "id", "name"), &VisualShaderNodeGroupBase::set_output_port_name);
-	ClassDB::bind_method(D_METHOD("set_output_port_type", "id", "type"), &VisualShaderNodeGroupBase::set_output_port_type);
-
-	ClassDB::bind_method(D_METHOD("get_free_input_port_id"), &VisualShaderNodeGroupBase::get_free_input_port_id);
-	ClassDB::bind_method(D_METHOD("get_free_output_port_id"), &VisualShaderNodeGroupBase::get_free_output_port_id);
-
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
-}
-
-String VisualShaderNodeGroupBase::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "";
-}
-
-VisualShaderNodeGroupBase::VisualShaderNodeGroupBase() {
-	size = Size2(0, 0);
-	inputs = "";
-	outputs = "";
-	editable = false;
-	simple_decl = false;
-}
-
-////////////// Expression
-
-String VisualShaderNodeExpression::get_caption() const {
-	return "Expression";
-}
-
-void VisualShaderNodeExpression::set_expression(const String &p_expression) {
-	expression = p_expression;
-}
-
-String VisualShaderNodeExpression::get_expression() const {
-	return expression;
-}
-
-String VisualShaderNodeExpression::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String _expression = expression;
-
-	_expression = _expression.insert(0, "\n");
-	_expression = _expression.replace("\n", "\n\t\t");
-
-	static Vector<String> pre_symbols;
-	if (pre_symbols.empty()) {
-		pre_symbols.push_back("\t");
-		pre_symbols.push_back(",");
-		pre_symbols.push_back(";");
-		pre_symbols.push_back("{");
-		pre_symbols.push_back("[");
-		pre_symbols.push_back("]");
-		pre_symbols.push_back("(");
-		pre_symbols.push_back(" ");
-		pre_symbols.push_back("-");
-		pre_symbols.push_back("*");
-		pre_symbols.push_back("/");
-		pre_symbols.push_back("+");
-		pre_symbols.push_back("=");
-		pre_symbols.push_back("&");
-		pre_symbols.push_back("|");
-		pre_symbols.push_back("!");
-	}
-
-	static Vector<String> post_symbols;
-	if (post_symbols.empty()) {
-		post_symbols.push_back("\t");
-		post_symbols.push_back("\n");
-		post_symbols.push_back(",");
-		post_symbols.push_back(";");
-		post_symbols.push_back("}");
-		post_symbols.push_back("[");
-		post_symbols.push_back("]");
-		post_symbols.push_back(")");
-		post_symbols.push_back(" ");
-		post_symbols.push_back(".");
-		post_symbols.push_back("-");
-		post_symbols.push_back("*");
-		post_symbols.push_back("/");
-		post_symbols.push_back("+");
-		post_symbols.push_back("=");
-		post_symbols.push_back("&");
-		post_symbols.push_back("|");
-		post_symbols.push_back("!");
-	}
-
-	for (int i = 0; i < get_input_port_count(); i++) {
-		for (int j = 0; j < pre_symbols.size(); j++) {
-			for (int k = 0; k < post_symbols.size(); k++) {
-				_expression = _expression.replace(pre_symbols[j] + get_input_port_name(i) + post_symbols[k], pre_symbols[j] + p_input_vars[i] + post_symbols[k]);
-			}
-		}
-	}
-	for (int i = 0; i < get_output_port_count(); i++) {
-		for (int j = 0; j < pre_symbols.size(); j++) {
-			for (int k = 0; k < post_symbols.size(); k++) {
-				_expression = _expression.replace(pre_symbols[j] + get_output_port_name(i) + post_symbols[k], pre_symbols[j] + p_output_vars[i] + post_symbols[k]);
-			}
-		}
-	}
-
-	String output_initializer;
-
-	for (int i = 0; i < get_output_port_count(); i++) {
-		int port_type = get_output_port_type(i);
-		String tk = "";
-		switch (port_type) {
-			case PORT_TYPE_SCALAR:
-				tk = "0.0";
-				break;
-			case PORT_TYPE_VECTOR:
-				tk = "vec3(0.0, 0.0, 0.0)";
-				break;
-			case PORT_TYPE_BOOLEAN:
-				tk = "false";
-				break;
-			case PORT_TYPE_TRANSFORM:
-				tk = "mat4(1.0)";
-				break;
-			default:
-				continue;
-		}
-		output_initializer += "\t" + p_output_vars[i] + " = " + tk + ";\n";
-	}
-
-	String code;
-	code += output_initializer;
-	code += "\t{";
-	code += _expression;
-	code += "\n\t}\n";
-
-	return code;
-}
-
-void VisualShaderNodeExpression::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_expression", "expression"), &VisualShaderNodeExpression::set_expression);
-	ClassDB::bind_method(D_METHOD("get_expression"), &VisualShaderNodeExpression::get_expression);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "expression"), "set_expression", "get_expression");
-}
-
-VisualShaderNodeExpression::VisualShaderNodeExpression() {
-	expression = "";
-	set_editable(true);
-}
-
-////////////// Global Expression
-
-String VisualShaderNodeGlobalExpression::get_caption() const {
-	return "GlobalExpression";
-}
-
-String VisualShaderNodeGlobalExpression::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	return expression;
-}
-
-VisualShaderNodeGlobalExpression::VisualShaderNodeGlobalExpression() {
-	set_editable(false);
-}
diff --git a/scene/resources/visual_shader.h b/scene/resources/visual_shader.h
deleted file mode 100644
index 5aaa42383..000000000
--- a/scene/resources/visual_shader.h
+++ /dev/null
@@ -1,559 +0,0 @@
-/*************************************************************************/
-/*  visual_shader.h                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef VISUAL_SHADER_H
-#define VISUAL_SHADER_H
-
-#include "core/string_builder.h"
-#include "scene/gui/control.h"
-#include "scene/resources/shader.h"
-
-class VisualShaderNodeUniform;
-class VisualShaderNode;
-
-class VisualShader : public Shader {
-	GDCLASS(VisualShader, Shader);
-
-public:
-	enum Type {
-		TYPE_VERTEX,
-		TYPE_FRAGMENT,
-		TYPE_LIGHT,
-		TYPE_MAX
-	};
-
-	struct Connection {
-		int from_node;
-		int from_port;
-		int to_node;
-		int to_port;
-	};
-
-	struct DefaultTextureParam {
-		StringName name;
-		Ref<Texture> param;
-	};
-
-private:
-	struct Node {
-		Ref<VisualShaderNode> node;
-		Vector2 position;
-		List<int> prev_connected_nodes;
-	};
-
-	struct Graph {
-		Map<int, Node> nodes;
-		List<Connection> connections;
-	} graph[TYPE_MAX];
-
-	Shader::Mode shader_mode;
-	mutable String previous_code;
-
-	Array _get_node_connections(Type p_type) const;
-
-	Vector2 graph_offset;
-
-	struct RenderModeEnums {
-		Shader::Mode mode;
-		const char *string;
-	};
-
-	HashMap<String, int> modes;
-	Set<StringName> flags;
-
-	static RenderModeEnums render_mode_enums[];
-
-	mutable SafeFlag dirty;
-	void _queue_update();
-
-	union ConnectionKey {
-		struct {
-			uint64_t node : 32;
-			uint64_t port : 32;
-		};
-		uint64_t key;
-		bool operator<(const ConnectionKey &p_key) const {
-			return key < p_key.key;
-		}
-	};
-
-	Error _write_node(Type p_type, StringBuilder &global_code, StringBuilder &global_code_per_node, Map<Type, StringBuilder> &global_code_per_func, StringBuilder &code, Vector<DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, Set<int> &processed, bool for_preview, Set<StringName> &r_classes) const;
-
-	void _input_type_changed(Type p_type, int p_id);
-
-protected:
-	virtual void _update_shader() const;
-	static void _bind_methods();
-
-	bool _set(const StringName &p_name, const Variant &p_value);
-	bool _get(const StringName &p_name, Variant &r_ret) const;
-	void _get_property_list(List<PropertyInfo> *p_list) const;
-
-public:
-	enum {
-		NODE_ID_INVALID = -1,
-		NODE_ID_OUTPUT = 0,
-	};
-
-	void add_node(Type p_type, const Ref<VisualShaderNode> &p_node, const Vector2 &p_position, int p_id);
-	void set_node_position(Type p_type, int p_id, const Vector2 &p_position);
-
-	Vector2 get_node_position(Type p_type, int p_id) const;
-	Ref<VisualShaderNode> get_node(Type p_type, int p_id) const;
-
-	Vector<int> get_node_list(Type p_type) const;
-	int get_valid_node_id(Type p_type) const;
-
-	int find_node_id(Type p_type, const Ref<VisualShaderNode> &p_node) const;
-	void remove_node(Type p_type, int p_id);
-
-	bool is_node_connection(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const;
-
-	bool is_nodes_connected_relatively(const Graph *p_graph, int p_node, int p_target) const;
-	bool can_connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const;
-	Error connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port);
-	void disconnect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port);
-	void connect_nodes_forced(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port);
-	bool is_port_types_compatible(int p_a, int p_b) const;
-
-	void rebuild();
-	void get_node_connections(Type p_type, List<Connection> *r_connections) const;
-
-	void set_mode(Mode p_mode);
-	virtual Mode get_mode() const;
-
-	virtual bool is_text_shader() const;
-
-	void set_graph_offset(const Vector2 &p_offset);
-	Vector2 get_graph_offset() const;
-
-	String generate_preview_shader(Type p_type, int p_node, int p_port, Vector<DefaultTextureParam> &r_default_tex_params) const;
-
-	String validate_port_name(const String &p_name, const List<String> &p_input_ports, const List<String> &p_output_ports) const;
-	String validate_uniform_name(const String &p_name, const Ref<VisualShaderNodeUniform> &p_uniform) const;
-
-	VisualShader();
-};
-
-VARIANT_ENUM_CAST(VisualShader::Type)
-///
-///
-///
-
-class VisualShaderNode : public Resource {
-	GDCLASS(VisualShaderNode, Resource);
-
-	int port_preview;
-
-	Map<int, Variant> default_input_values;
-	Map<int, bool> connected_input_ports;
-	Map<int, int> connected_output_ports;
-
-protected:
-	bool simple_decl;
-	static void _bind_methods();
-
-public:
-	enum PortType {
-		PORT_TYPE_SCALAR,
-		PORT_TYPE_VECTOR,
-		PORT_TYPE_BOOLEAN,
-		PORT_TYPE_TRANSFORM,
-		PORT_TYPE_SAMPLER,
-		PORT_TYPE_MAX,
-	};
-
-	bool is_simple_decl() const;
-
-	virtual String get_caption() const = 0;
-
-	virtual int get_input_port_count() const = 0;
-	virtual PortType get_input_port_type(int p_port) const = 0;
-	virtual String get_input_port_name(int p_port) const = 0;
-
-	virtual void set_input_port_default_value(int p_port, const Variant &p_value);
-	Variant get_input_port_default_value(int p_port) const; // if NIL (default if node does not set anything) is returned, it means no default value is wanted if disconnected, thus no input var must be supplied (empty string will be supplied)
-	Array get_default_input_values() const;
-	virtual void set_default_input_values(const Array &p_values);
-
-	virtual int get_output_port_count() const = 0;
-	virtual PortType get_output_port_type(int p_port) const = 0;
-	virtual String get_output_port_name(int p_port) const = 0;
-
-	virtual String get_input_port_default_hint(int p_port) const;
-
-	void set_output_port_for_preview(int p_index);
-	int get_output_port_for_preview() const;
-
-	virtual bool is_port_separator(int p_index) const;
-
-	bool is_output_port_connected(int p_port) const;
-	void set_output_port_connected(int p_port, bool p_connected);
-	bool is_input_port_connected(int p_port) const;
-	void set_input_port_connected(int p_port, bool p_connected);
-	virtual bool is_generate_input_var(int p_port) const;
-
-	virtual bool is_code_generated() const;
-	virtual bool is_show_prop_names() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const = 0; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
-
-	VisualShaderNode();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNode::PortType)
-
-class VisualShaderNodeCustom : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeCustom, VisualShaderNode);
-
-	struct Port {
-		String name;
-		int type;
-	};
-
-	bool is_initialized = false;
-	List<Port> input_ports;
-	List<Port> output_ports;
-
-	friend class VisualShaderEditor;
-
-protected:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual void set_input_port_default_value(int p_port, const Variant &p_value);
-	virtual void set_default_input_values(const Array &p_values);
-
-protected:
-	void _set_input_port_default_value(int p_port, const Variant &p_value);
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-	virtual String generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-
-	static void _bind_methods();
-
-public:
-	VisualShaderNodeCustom();
-	void update_ports();
-
-	bool _is_initialized();
-	void _set_initialized(bool p_enabled);
-};
-
-/////
-
-class VisualShaderNodeInput : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeInput, VisualShaderNode);
-
-	friend class VisualShader;
-	VisualShader::Type shader_type;
-	Shader::Mode shader_mode;
-
-	struct Port {
-		Shader::Mode mode;
-		VisualShader::Type shader_type;
-		PortType type;
-		const char *name;
-		const char *string;
-	};
-
-	static const Port ports[];
-	static const Port preview_ports[];
-
-	String input_name;
-
-protected:
-	static void _bind_methods();
-	void _validate_property(PropertyInfo &property) const;
-
-public:
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String get_caption() const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	void set_input_name(String p_name);
-	String get_input_name() const;
-	String get_input_real_name() const;
-
-	int get_input_index_count() const;
-	PortType get_input_index_type(int p_index) const;
-	String get_input_index_name(int p_index) const;
-
-	PortType get_input_type_by_name(String p_name) const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeInput();
-};
-
-///
-
-class VisualShaderNodeOutput : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeOutput, VisualShaderNode);
-
-public:
-	friend class VisualShader;
-	VisualShader::Type shader_type;
-	Shader::Mode shader_mode;
-
-	struct Port {
-		Shader::Mode mode;
-		VisualShader::Type shader_type;
-		PortType type;
-		const char *name;
-		const char *string;
-	};
-
-	static const Port ports[];
-
-public:
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-	Variant get_input_port_default_value(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual bool is_port_separator(int p_index) const;
-
-	virtual String get_caption() const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeOutput();
-};
-
-class VisualShaderNodeUniform : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeUniform, VisualShaderNode);
-
-private:
-	String uniform_name;
-	bool global_code_generated = false;
-
-protected:
-	static void _bind_methods();
-
-public:
-	void set_global_code_generated(bool p_enabled);
-	bool is_global_code_generated() const;
-
-	virtual bool is_show_prop_names() const;
-
-	void set_uniform_name(const String &p_name);
-	String get_uniform_name() const;
-
-	VisualShaderNodeUniform();
-};
-
-class VisualShaderNodeUniformRef : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeUniformRef, VisualShaderNode);
-
-public:
-	enum UniformType {
-		UNIFORM_TYPE_SCALAR,
-		UNIFORM_TYPE_BOOLEAN,
-		UNIFORM_TYPE_VECTOR,
-		UNIFORM_TYPE_TRANSFORM,
-		UNIFORM_TYPE_COLOR,
-		UNIFORM_TYPE_SAMPLER,
-	};
-
-	struct Uniform {
-		String name;
-		UniformType type;
-	};
-
-private:
-	String uniform_name;
-	UniformType uniform_type;
-
-protected:
-	static void _bind_methods();
-
-public:
-	static void add_uniform(const String &p_name, UniformType p_type);
-	static void clear_uniforms();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	void set_uniform_name(const String &p_name);
-	String get_uniform_name() const;
-
-	int get_uniforms_count() const;
-	String get_uniform_name_by_index(int p_idx) const;
-	UniformType get_uniform_type_by_name(const String &p_name) const;
-	UniformType get_uniform_type_by_index(int p_idx) const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeUniformRef();
-};
-
-class VisualShaderNodeGroupBase : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeGroupBase, VisualShaderNode);
-
-private:
-	void _apply_port_changes();
-
-protected:
-	Vector2 size;
-	String inputs;
-	String outputs;
-	bool editable;
-
-	struct Port {
-		PortType type;
-		String name;
-	};
-
-	Map<int, Port> input_ports;
-	Map<int, Port> output_ports;
-	Map<int, Control *> controls;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	void set_size(const Vector2 &p_size);
-	Vector2 get_size() const;
-
-	void set_inputs(const String &p_inputs);
-	String get_inputs() const;
-
-	void set_outputs(const String &p_outputs);
-	String get_outputs() const;
-
-	bool is_valid_port_name(const String &p_name) const;
-
-	void add_input_port(int p_id, int p_type, const String &p_name);
-	void remove_input_port(int p_id);
-	virtual int get_input_port_count() const;
-	bool has_input_port(int p_id) const;
-	void clear_input_ports();
-
-	void add_output_port(int p_id, int p_type, const String &p_name);
-	void remove_output_port(int p_id);
-	virtual int get_output_port_count() const;
-	bool has_output_port(int p_id) const;
-	void clear_output_ports();
-
-	void set_input_port_type(int p_id, int p_type);
-	virtual PortType get_input_port_type(int p_id) const;
-	void set_input_port_name(int p_id, const String &p_name);
-	virtual String get_input_port_name(int p_id) const;
-
-	void set_output_port_type(int p_id, int p_type);
-	virtual PortType get_output_port_type(int p_id) const;
-	void set_output_port_name(int p_id, const String &p_name);
-	virtual String get_output_port_name(int p_id) const;
-
-	int get_free_input_port_id() const;
-	int get_free_output_port_id() const;
-
-	void set_control(Control *p_control, int p_index);
-	Control *get_control(int p_index);
-
-	void set_editable(bool p_enabled);
-	bool is_editable() const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeGroupBase();
-};
-
-class VisualShaderNodeExpression : public VisualShaderNodeGroupBase {
-	GDCLASS(VisualShaderNodeExpression, VisualShaderNodeGroupBase);
-
-protected:
-	String expression;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	void set_expression(const String &p_expression);
-	String get_expression() const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeExpression();
-};
-
-class VisualShaderNodeGlobalExpression : public VisualShaderNodeExpression {
-	GDCLASS(VisualShaderNodeGlobalExpression, VisualShaderNodeExpression);
-
-public:
-	virtual String get_caption() const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-
-	VisualShaderNodeGlobalExpression();
-};
-
-#endif // VISUAL_SHADER_H
diff --git a/scene/resources/visual_shader_nodes.cpp b/scene/resources/visual_shader_nodes.cpp
deleted file mode 100644
index 815e9a360..000000000
--- a/scene/resources/visual_shader_nodes.cpp
+++ /dev/null
@@ -1,4420 +0,0 @@
-/*************************************************************************/
-/*  visual_shader_nodes.cpp                                              */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "visual_shader_nodes.h"
-
-////////////// Scalar
-
-String VisualShaderNodeScalarConstant::get_caption() const {
-	return "Scalar";
-}
-
-int VisualShaderNodeScalarConstant::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeScalarConstant::PortType VisualShaderNodeScalarConstant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarConstant::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeScalarConstant::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarConstant::PortType VisualShaderNodeScalarConstant::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarConstant::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeScalarConstant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + vformat("%.6f", constant) + ";\n";
-}
-
-void VisualShaderNodeScalarConstant::set_constant(float p_value) {
-	constant = p_value;
-	emit_changed();
-}
-
-float VisualShaderNodeScalarConstant::get_constant() const {
-	return constant;
-}
-
-Vector<StringName> VisualShaderNodeScalarConstant::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("constant");
-	return props;
-}
-
-void VisualShaderNodeScalarConstant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant", "value"), &VisualShaderNodeScalarConstant::set_constant);
-	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeScalarConstant::get_constant);
-
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "constant"), "set_constant", "get_constant");
-}
-
-VisualShaderNodeScalarConstant::VisualShaderNodeScalarConstant() {
-	constant = 0;
-}
-
-////////////// Boolean
-
-String VisualShaderNodeBooleanConstant::get_caption() const {
-	return "Boolean";
-}
-
-int VisualShaderNodeBooleanConstant::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeBooleanConstant::PortType VisualShaderNodeBooleanConstant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeBooleanConstant::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeBooleanConstant::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeBooleanConstant::PortType VisualShaderNodeBooleanConstant::get_output_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeBooleanConstant::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeBooleanConstant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + (constant ? "true" : "false") + ";\n";
-}
-
-void VisualShaderNodeBooleanConstant::set_constant(bool p_value) {
-	constant = p_value;
-	emit_changed();
-}
-
-bool VisualShaderNodeBooleanConstant::get_constant() const {
-	return constant;
-}
-
-Vector<StringName> VisualShaderNodeBooleanConstant::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("constant");
-	return props;
-}
-
-void VisualShaderNodeBooleanConstant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant", "value"), &VisualShaderNodeBooleanConstant::set_constant);
-	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeBooleanConstant::get_constant);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "constant"), "set_constant", "get_constant");
-}
-
-VisualShaderNodeBooleanConstant::VisualShaderNodeBooleanConstant() {
-	constant = false;
-}
-
-////////////// Color
-
-String VisualShaderNodeColorConstant::get_caption() const {
-	return "Color";
-}
-
-int VisualShaderNodeColorConstant::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeColorConstant::PortType VisualShaderNodeColorConstant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorConstant::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeColorConstant::get_output_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeColorConstant::PortType VisualShaderNodeColorConstant::get_output_port_type(int p_port) const {
-	return p_port == 0 ? PORT_TYPE_VECTOR : PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeColorConstant::get_output_port_name(int p_port) const {
-	return p_port == 0 ? "" : "alpha"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeColorConstant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + vformat("vec3(%.6f, %.6f, %.6f)", constant.r, constant.g, constant.b) + ";\n";
-	code += "\t" + p_output_vars[1] + " = " + vformat("%.6f", constant.a) + ";\n";
-
-	return code;
-}
-
-void VisualShaderNodeColorConstant::set_constant(Color p_value) {
-	constant = p_value;
-	emit_changed();
-}
-
-Color VisualShaderNodeColorConstant::get_constant() const {
-	return constant;
-}
-
-Vector<StringName> VisualShaderNodeColorConstant::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("constant");
-	return props;
-}
-
-void VisualShaderNodeColorConstant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant", "value"), &VisualShaderNodeColorConstant::set_constant);
-	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeColorConstant::get_constant);
-
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "constant"), "set_constant", "get_constant");
-}
-
-VisualShaderNodeColorConstant::VisualShaderNodeColorConstant() {
-	constant = Color(1, 1, 1, 1);
-}
-
-////////////// Vector
-
-String VisualShaderNodeVec3Constant::get_caption() const {
-	return "Vector";
-}
-
-int VisualShaderNodeVec3Constant::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeVec3Constant::PortType VisualShaderNodeVec3Constant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVec3Constant::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeVec3Constant::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVec3Constant::PortType VisualShaderNodeVec3Constant::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVec3Constant::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeVec3Constant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + vformat("vec3(%.6f, %.6f, %.6f)", constant.x, constant.y, constant.z) + ";\n";
-}
-
-void VisualShaderNodeVec3Constant::set_constant(Vector3 p_value) {
-	constant = p_value;
-	emit_changed();
-}
-
-Vector3 VisualShaderNodeVec3Constant::get_constant() const {
-	return constant;
-}
-
-Vector<StringName> VisualShaderNodeVec3Constant::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("constant");
-	return props;
-}
-
-void VisualShaderNodeVec3Constant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant", "value"), &VisualShaderNodeVec3Constant::set_constant);
-	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeVec3Constant::get_constant);
-
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant"), "set_constant", "get_constant");
-}
-
-VisualShaderNodeVec3Constant::VisualShaderNodeVec3Constant() {
-}
-
-////////////// Transform
-
-String VisualShaderNodeTransformConstant::get_caption() const {
-	return "Transform";
-}
-
-int VisualShaderNodeTransformConstant::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeTransformConstant::PortType VisualShaderNodeTransformConstant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformConstant::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeTransformConstant::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformConstant::PortType VisualShaderNodeTransformConstant::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformConstant::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeTransformConstant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	Transform t = constant;
-	t.basis.transpose();
-
-	String code = "\t" + p_output_vars[0] + " = mat4(";
-	code += vformat("vec4(%.6f, %.6f, %.6f, 0.0), ", t.basis[0].x, t.basis[0].y, t.basis[0].z);
-	code += vformat("vec4(%.6f, %.6f, %.6f, 0.0), ", t.basis[1].x, t.basis[1].y, t.basis[1].z);
-	code += vformat("vec4(%.6f, %.6f, %.6f, 0.0), ", t.basis[2].x, t.basis[2].y, t.basis[2].z);
-	code += vformat("vec4(%.6f, %.6f, %.6f, 1.0));\n", t.origin.x, t.origin.y, t.origin.z);
-	return code;
-}
-
-void VisualShaderNodeTransformConstant::set_constant(Transform p_value) {
-	constant = p_value;
-	emit_changed();
-}
-
-Transform VisualShaderNodeTransformConstant::get_constant() const {
-	return constant;
-}
-
-Vector<StringName> VisualShaderNodeTransformConstant::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("constant");
-	return props;
-}
-
-void VisualShaderNodeTransformConstant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_constant", "value"), &VisualShaderNodeTransformConstant::set_constant);
-	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeTransformConstant::get_constant);
-
-	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "constant"), "set_constant", "get_constant");
-}
-
-VisualShaderNodeTransformConstant::VisualShaderNodeTransformConstant() {
-}
-
-////////////// Texture
-
-String VisualShaderNodeTexture::get_caption() const {
-	return "Texture";
-}
-
-int VisualShaderNodeTexture::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeTexture::PortType VisualShaderNodeTexture::get_input_port_type(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return PORT_TYPE_VECTOR;
-		case 1:
-			return PORT_TYPE_SCALAR;
-		case 2:
-			return PORT_TYPE_SAMPLER;
-		default:
-			return PORT_TYPE_SCALAR;
-	}
-}
-
-String VisualShaderNodeTexture::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "uv";
-		case 1:
-			return "lod";
-		case 2:
-			return "sampler2D";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeTexture::get_output_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeTexture::PortType VisualShaderNodeTexture::get_output_port_type(int p_port) const {
-	if (p_port == 0 && source == SOURCE_DEPTH) {
-		return PORT_TYPE_SCALAR;
-	}
-	return p_port == 0 ? PORT_TYPE_VECTOR : PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeTexture::get_output_port_name(int p_port) const {
-	if (p_port == 0 && source == SOURCE_DEPTH) {
-		return "depth";
-	}
-	return p_port == 0 ? "rgb" : "alpha";
-}
-
-String VisualShaderNodeTexture::get_input_port_default_hint(int p_port) const {
-	if (p_port == 0) {
-		return "UV.xy";
-	}
-	return "";
-}
-
-static String make_unique_id(VisualShader::Type p_type, int p_id, const String &p_name) {
-	static const char *typepf[VisualShader::TYPE_MAX] = { "vtx", "frg", "lgt" };
-	return p_name + "_" + String(typepf[p_type]) + "_" + itos(p_id);
-}
-
-Vector<VisualShader::DefaultTextureParam> VisualShaderNodeTexture::get_default_texture_parameters(VisualShader::Type p_type, int p_id) const {
-	VisualShader::DefaultTextureParam dtp;
-	dtp.name = make_unique_id(p_type, p_id, "tex");
-	dtp.param = texture;
-	Vector<VisualShader::DefaultTextureParam> ret;
-	ret.push_back(dtp);
-	return ret;
-}
-
-String VisualShaderNodeTexture::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	if (source == SOURCE_TEXTURE) {
-		String u = "uniform sampler2D " + make_unique_id(p_type, p_id, "tex");
-		switch (texture_type) {
-			case TYPE_DATA:
-				break;
-			case TYPE_COLOR:
-				u += " : hint_albedo";
-				break;
-			case TYPE_NORMALMAP:
-				u += " : hint_normal";
-				break;
-		}
-		return u + ";\n";
-	}
-
-	return String();
-}
-
-String VisualShaderNodeTexture::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	if (source == SOURCE_TEXTURE) {
-		String id = make_unique_id(p_type, p_id, "tex");
-		String code;
-		if (p_input_vars[0] == String()) { // Use UV by default.
-
-			if (p_input_vars[1] == String()) {
-				code += "\tvec4 " + id + "_read = texture(" + id + ", UV.xy);\n";
-			} else {
-				code += "\tvec4 " + id + "_read = textureLod(" + id + ", UV.xy, " + p_input_vars[1] + ");\n";
-			}
-
-		} else if (p_input_vars[1] == String()) {
-			//no lod
-			code += "\tvec4 " + id + "_read = texture(" + id + ", " + p_input_vars[0] + ".xy);\n";
-		} else {
-			code += "\tvec4 " + id + "_read = textureLod(" + id + ", " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-		}
-
-		code += "\t" + p_output_vars[0] + " = " + id + "_read.rgb;\n";
-		code += "\t" + p_output_vars[1] + " = " + id + "_read.a;\n";
-		return code;
-	}
-
-	if (source == SOURCE_PORT) {
-		String id = p_input_vars[2];
-
-		String code;
-		code += "\t{\n";
-		if (id == String()) {
-			code += "\t\tvec4 " + id + "_tex_read = vec4(0.0);\n";
-		} else {
-			if (p_input_vars[0] == String()) { // Use UV by default.
-
-				if (p_input_vars[1] == String()) {
-					code += "\t\tvec4 " + id + "_tex_read = texture(" + id + ", UV.xy);\n";
-				} else {
-					code += "\t\tvec4 " + id + "_tex_read = textureLod(" + id + ", UV.xy, " + p_input_vars[1] + ");\n";
-				}
-
-			} else if (p_input_vars[1] == String()) {
-				//no lod
-				code += "\t\tvec4 " + id + "_tex_read = texture(" + id + ", " + p_input_vars[0] + ".xy);\n";
-			} else {
-				code += "\t\tvec4 " + id + "_tex_read = textureLod(" + id + ", " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-			}
-
-			code += "\t\t" + p_output_vars[0] + " = " + id + "_tex_read.rgb;\n";
-			code += "\t\t" + p_output_vars[1] + " = " + id + "_tex_read.a;\n";
-		}
-		code += "\t}\n";
-		return code;
-	}
-
-	if (source == SOURCE_SCREEN && (p_mode == Shader::MODE_SPATIAL || p_mode == Shader::MODE_CANVAS_ITEM) && p_type == VisualShader::TYPE_FRAGMENT) {
-		String code = "\t{\n";
-		if (p_input_vars[0] == String() || p_for_preview) { // Use UV by default.
-
-			if (p_input_vars[1] == String()) {
-				code += "\t\tvec4 _tex_read = textureLod(SCREEN_TEXTURE, UV.xy, 0.0 );\n";
-			} else {
-				code += "\t\tvec4 _tex_read = textureLod(SCREEN_TEXTURE, UV.xy, " + p_input_vars[1] + ");\n";
-			}
-
-		} else if (p_input_vars[1] == String()) {
-			//no lod
-			code += "\t\tvec4 _tex_read = textureLod(SCREEN_TEXTURE, " + p_input_vars[0] + ".xy, 0.0);\n";
-		} else {
-			code += "\t\tvec4 _tex_read = textureLod(SCREEN_TEXTURE, " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-		}
-
-		code += "\t\t" + p_output_vars[0] + " = _tex_read.rgb;\n";
-		code += "\t\t" + p_output_vars[1] + " = _tex_read.a;\n";
-		code += "\t}\n";
-		return code;
-	}
-
-	if (source == SOURCE_2D_TEXTURE && p_mode == Shader::MODE_CANVAS_ITEM && p_type == VisualShader::TYPE_FRAGMENT) {
-		String code = "\t{\n";
-		if (p_input_vars[0] == String()) { // Use UV by default.
-
-			if (p_input_vars[1] == String()) {
-				code += "\t\tvec4 _tex_read = texture(TEXTURE , UV.xy);\n";
-			} else {
-				code += "\t\tvec4 _tex_read = textureLod(TEXTURE, UV.xy, " + p_input_vars[1] + ");\n";
-			}
-
-		} else if (p_input_vars[1] == String()) {
-			//no lod
-			code += "\t\tvec4 _tex_read = texture(TEXTURE, " + p_input_vars[0] + ".xy);\n";
-		} else {
-			code += "\t\tvec4 _tex_read = textureLod(TEXTURE, " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-		}
-
-		code += "\t\t" + p_output_vars[0] + " = _tex_read.rgb;\n";
-		code += "\t\t" + p_output_vars[1] + " = _tex_read.a;\n";
-		code += "\t}\n";
-		return code;
-	}
-
-	if (source == SOURCE_2D_NORMAL && p_mode == Shader::MODE_CANVAS_ITEM && p_type == VisualShader::TYPE_FRAGMENT) {
-		String code = "\t{\n";
-		if (p_input_vars[0] == String()) { // Use UV by default.
-
-			if (p_input_vars[1] == String()) {
-				code += "\t\tvec4 _tex_read = texture(NORMAL_TEXTURE, UV.xy);\n";
-			} else {
-				code += "\t\tvec4 _tex_read = textureLod(NORMAL_TEXTURE, UV.xy, " + p_input_vars[1] + ");\n";
-			}
-
-		} else if (p_input_vars[1] == String()) {
-			//no lod
-			code += "\t\tvec4 _tex_read = texture(NORMAL_TEXTURE, " + p_input_vars[0] + ".xy);\n";
-		} else {
-			code += "\t\tvec4 _tex_read = textureLod(NORMAL_TEXTURE, " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-		}
-
-		code += "\t\t" + p_output_vars[0] + " = _tex_read.rgb;\n";
-		code += "\t\t" + p_output_vars[1] + " = _tex_read.a;\n";
-		code += "\t}\n";
-		return code;
-	}
-
-	if (p_for_preview) // DEPTH_TEXTURE is not supported in preview(canvas_item) shader
-	{
-		if (source == SOURCE_DEPTH) {
-			String code;
-			code += "\t" + p_output_vars[0] + " = 0.0;\n";
-			code += "\t" + p_output_vars[1] + " = 1.0;\n";
-			return code;
-		}
-	}
-
-	if (source == SOURCE_DEPTH && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
-		String code = "\t{\n";
-		if (p_input_vars[0] == String()) { // Use UV by default.
-
-			if (p_input_vars[1] == String()) {
-				code += "\t\tfloat _depth = texture(DEPTH_TEXTURE, UV.xy).r;\n";
-			} else {
-				code += "\t\tfloat _depth = textureLod(DEPTH_TEXTURE, UV.xy, " + p_input_vars[1] + ").r;\n";
-			}
-
-		} else if (p_input_vars[1] == String()) {
-			//no lod
-			code += "\t\tfloat _depth = texture(DEPTH_TEXTURE, " + p_input_vars[0] + ".xy).r;\n";
-		} else {
-			code += "\t\tfloat _depth = textureLod(DEPTH_TEXTURE, " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ").r;\n";
-		}
-
-		code += "\t\t" + p_output_vars[0] + " = _depth;\n";
-		code += "\t\t" + p_output_vars[1] + " = 1.0;\n";
-		code += "\t}\n";
-		return code;
-	} else if (source == SOURCE_DEPTH) {
-		String code;
-		code += "\t" + p_output_vars[0] + " = 0.0;\n";
-		code += "\t" + p_output_vars[1] + " = 1.0;\n";
-		return code;
-	}
-
-	//none
-	String code;
-	code += "\t" + p_output_vars[0] + " = vec3(0.0);\n";
-	code += "\t" + p_output_vars[1] + " = 1.0;\n";
-	return code;
-}
-
-void VisualShaderNodeTexture::set_source(Source p_source) {
-	source = p_source;
-	switch (source) {
-		case SOURCE_TEXTURE:
-			simple_decl = true;
-			break;
-		case SOURCE_SCREEN:
-			simple_decl = false;
-			break;
-		case SOURCE_2D_TEXTURE:
-			simple_decl = false;
-			break;
-		case SOURCE_2D_NORMAL:
-			simple_decl = false;
-			break;
-		case SOURCE_DEPTH:
-			simple_decl = false;
-			break;
-		case SOURCE_PORT:
-			simple_decl = false;
-			break;
-	}
-	emit_changed();
-	emit_signal("editor_refresh_request");
-}
-
-VisualShaderNodeTexture::Source VisualShaderNodeTexture::get_source() const {
-	return source;
-}
-
-void VisualShaderNodeTexture::set_texture(Ref<Texture> p_value) {
-	texture = p_value;
-	emit_changed();
-}
-
-Ref<Texture> VisualShaderNodeTexture::get_texture() const {
-	return texture;
-}
-
-void VisualShaderNodeTexture::set_texture_type(TextureType p_type) {
-	texture_type = p_type;
-	emit_changed();
-}
-
-VisualShaderNodeTexture::TextureType VisualShaderNodeTexture::get_texture_type() const {
-	return texture_type;
-}
-
-Vector<StringName> VisualShaderNodeTexture::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("source");
-	if (source == SOURCE_TEXTURE) {
-		props.push_back("texture");
-		props.push_back("texture_type");
-	}
-	return props;
-}
-
-String VisualShaderNodeTexture::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
-	if (is_input_port_connected(2) && source != SOURCE_PORT) {
-		return TTR("The sampler port is connected but not used. Consider changing the source to 'SamplerPort'.");
-	}
-
-	if (source == SOURCE_TEXTURE) {
-		return String(); // all good
-	}
-
-	if (source == SOURCE_PORT) {
-		return String(); // all good
-	}
-
-	if (source == SOURCE_SCREEN && (p_mode == Shader::MODE_SPATIAL || p_mode == Shader::MODE_CANVAS_ITEM) && p_type == VisualShader::TYPE_FRAGMENT) {
-		return String(); // all good
-	}
-
-	if (source == SOURCE_2D_TEXTURE && p_mode == Shader::MODE_CANVAS_ITEM && p_type == VisualShader::TYPE_FRAGMENT) {
-		return String(); // all good
-	}
-
-	if (source == SOURCE_2D_NORMAL && p_mode == Shader::MODE_CANVAS_ITEM) {
-		return String(); // all good
-	}
-
-	if (source == SOURCE_DEPTH && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
-		if (get_output_port_for_preview() == 0) { // DEPTH_TEXTURE is not supported in preview(canvas_item) shader
-			return TTR("Invalid source for preview.");
-		}
-		return String(); // all good
-	}
-
-	return TTR("Invalid source for shader.");
-}
-
-void VisualShaderNodeTexture::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_source", "value"), &VisualShaderNodeTexture::set_source);
-	ClassDB::bind_method(D_METHOD("get_source"), &VisualShaderNodeTexture::get_source);
-
-	ClassDB::bind_method(D_METHOD("set_texture", "value"), &VisualShaderNodeTexture::set_texture);
-	ClassDB::bind_method(D_METHOD("get_texture"), &VisualShaderNodeTexture::get_texture);
-
-	ClassDB::bind_method(D_METHOD("set_texture_type", "value"), &VisualShaderNodeTexture::set_texture_type);
-	ClassDB::bind_method(D_METHOD("get_texture_type"), &VisualShaderNodeTexture::get_texture_type);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "source", PROPERTY_HINT_ENUM, "Texture,Screen,Texture2D,NormalMap2D,Depth,SamplerPort"), "set_source", "get_source");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_type", PROPERTY_HINT_ENUM, "Data,Color,Normalmap"), "set_texture_type", "get_texture_type");
-
-	BIND_ENUM_CONSTANT(SOURCE_TEXTURE);
-	BIND_ENUM_CONSTANT(SOURCE_SCREEN);
-	BIND_ENUM_CONSTANT(SOURCE_2D_TEXTURE);
-	BIND_ENUM_CONSTANT(SOURCE_2D_NORMAL);
-	BIND_ENUM_CONSTANT(SOURCE_DEPTH);
-	BIND_ENUM_CONSTANT(SOURCE_PORT);
-	BIND_ENUM_CONSTANT(TYPE_DATA);
-	BIND_ENUM_CONSTANT(TYPE_COLOR);
-	BIND_ENUM_CONSTANT(TYPE_NORMALMAP);
-}
-
-VisualShaderNodeTexture::VisualShaderNodeTexture() {
-	texture_type = TYPE_DATA;
-	source = SOURCE_TEXTURE;
-}
-
-////////////// CubeMap
-
-String VisualShaderNodeCubeMap::get_caption() const {
-	return "CubeMap";
-}
-
-int VisualShaderNodeCubeMap::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeCubeMap::PortType VisualShaderNodeCubeMap::get_input_port_type(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return PORT_TYPE_VECTOR;
-		case 1:
-			return PORT_TYPE_SCALAR;
-		case 2:
-			return PORT_TYPE_SAMPLER;
-		default:
-			return PORT_TYPE_SCALAR;
-	}
-}
-
-String VisualShaderNodeCubeMap::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "uv";
-		case 1:
-			return "lod";
-		case 2:
-			return "samplerCube";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeCubeMap::get_output_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeCubeMap::PortType VisualShaderNodeCubeMap::get_output_port_type(int p_port) const {
-	return p_port == 0 ? PORT_TYPE_VECTOR : PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeCubeMap::get_output_port_name(int p_port) const {
-	return p_port == 0 ? "rgb" : "alpha";
-}
-
-Vector<VisualShader::DefaultTextureParam> VisualShaderNodeCubeMap::get_default_texture_parameters(VisualShader::Type p_type, int p_id) const {
-	VisualShader::DefaultTextureParam dtp;
-	dtp.name = make_unique_id(p_type, p_id, "cube");
-	dtp.param = cube_map;
-	Vector<VisualShader::DefaultTextureParam> ret;
-	ret.push_back(dtp);
-	return ret;
-}
-
-String VisualShaderNodeCubeMap::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	if (source == SOURCE_TEXTURE) {
-		String u = "uniform samplerCube " + make_unique_id(p_type, p_id, "cube");
-		switch (texture_type) {
-			case TYPE_DATA:
-				break;
-			case TYPE_COLOR:
-				u += " : hint_albedo";
-				break;
-			case TYPE_NORMALMAP:
-				u += " : hint_normal";
-				break;
-		}
-		return u + ";\n";
-	}
-	return String();
-}
-
-String VisualShaderNodeCubeMap::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	String id;
-	if (source == SOURCE_TEXTURE) {
-		id = make_unique_id(p_type, p_id, "cube");
-	} else if (source == SOURCE_PORT) {
-		id = p_input_vars[2];
-	} else {
-		return String();
-	}
-
-	code += "\t{\n";
-
-	if (id == String()) {
-		code += "\t\tvec4 " + id + "_read = vec4(0.0);\n";
-		code += "\t\t" + p_output_vars[0] + " = " + id + "_read.rgb;\n";
-		code += "\t\t" + p_output_vars[1] + " = " + id + "_read.a;\n";
-		code += "\t}\n";
-		return code;
-	}
-
-	if (p_input_vars[0] == String()) { // Use UV by default.
-
-		if (p_input_vars[1] == String()) {
-			code += "\t\tvec4 " + id + "_read = texture(" + id + " , vec3(UV, 0.0));\n";
-		} else {
-			code += "\t\tvec4 " + id + "_read = textureLod(" + id + " , vec3(UV, 0.0)" + " , " + p_input_vars[1] + " );\n";
-		}
-
-	} else if (p_input_vars[1] == String()) {
-		//no lod
-		code += "\t\tvec4 " + id + "_read = texture(" + id + ", " + p_input_vars[0] + ");\n";
-	} else {
-		code += "\t\tvec4 " + id + "_read = textureLod(" + id + ", " + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-	}
-	code += "\t\t" + p_output_vars[0] + " = " + id + "_read.rgb;\n";
-	code += "\t\t" + p_output_vars[1] + " = " + id + "_read.a;\n";
-	code += "\t}\n";
-
-	return code;
-}
-
-String VisualShaderNodeCubeMap::get_input_port_default_hint(int p_port) const {
-	if (p_port == 0) {
-		return "vec3(UV, 0.0)";
-	}
-	return "";
-}
-
-void VisualShaderNodeCubeMap::set_source(Source p_source) {
-	source = p_source;
-	emit_changed();
-	emit_signal("editor_refresh_request");
-}
-
-VisualShaderNodeCubeMap::Source VisualShaderNodeCubeMap::get_source() const {
-	return source;
-}
-
-void VisualShaderNodeCubeMap::set_cube_map(Ref<CubeMap> p_value) {
-	cube_map = p_value;
-	emit_changed();
-}
-
-Ref<CubeMap> VisualShaderNodeCubeMap::get_cube_map() const {
-	return cube_map;
-}
-
-void VisualShaderNodeCubeMap::set_texture_type(TextureType p_type) {
-	texture_type = p_type;
-	emit_changed();
-}
-
-VisualShaderNodeCubeMap::TextureType VisualShaderNodeCubeMap::get_texture_type() const {
-	return texture_type;
-}
-
-Vector<StringName> VisualShaderNodeCubeMap::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("source");
-	if (source == SOURCE_TEXTURE) {
-		props.push_back("cube_map");
-		props.push_back("texture_type");
-	}
-	return props;
-}
-
-String VisualShaderNodeCubeMap::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
-	if (is_input_port_connected(2) && source != SOURCE_PORT) {
-		return TTR("The sampler port is connected but not used. Consider changing the source to 'SamplerPort'.");
-	}
-	return String();
-}
-
-void VisualShaderNodeCubeMap::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_source", "value"), &VisualShaderNodeCubeMap::set_source);
-	ClassDB::bind_method(D_METHOD("get_source"), &VisualShaderNodeCubeMap::get_source);
-
-	ClassDB::bind_method(D_METHOD("set_cube_map", "value"), &VisualShaderNodeCubeMap::set_cube_map);
-	ClassDB::bind_method(D_METHOD("get_cube_map"), &VisualShaderNodeCubeMap::get_cube_map);
-
-	ClassDB::bind_method(D_METHOD("set_texture_type", "value"), &VisualShaderNodeCubeMap::set_texture_type);
-	ClassDB::bind_method(D_METHOD("get_texture_type"), &VisualShaderNodeCubeMap::get_texture_type);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "source", PROPERTY_HINT_ENUM, "Texture,SamplerPort"), "set_source", "get_source");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "cube_map", PROPERTY_HINT_RESOURCE_TYPE, "CubeMap"), "set_cube_map", "get_cube_map");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_type", PROPERTY_HINT_ENUM, "Data,Color,Normalmap"), "set_texture_type", "get_texture_type");
-
-	BIND_ENUM_CONSTANT(SOURCE_TEXTURE);
-	BIND_ENUM_CONSTANT(SOURCE_PORT);
-
-	BIND_ENUM_CONSTANT(TYPE_DATA);
-	BIND_ENUM_CONSTANT(TYPE_COLOR);
-	BIND_ENUM_CONSTANT(TYPE_NORMALMAP);
-}
-
-VisualShaderNodeCubeMap::VisualShaderNodeCubeMap() {
-	texture_type = TYPE_DATA;
-	source = SOURCE_TEXTURE;
-	simple_decl = false;
-}
-
-////////////// Scalar Op
-
-String VisualShaderNodeScalarOp::get_caption() const {
-	return "ScalarOp";
-}
-
-int VisualShaderNodeScalarOp::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeScalarOp::PortType VisualShaderNodeScalarOp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarOp::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeScalarOp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarOp::PortType VisualShaderNodeScalarOp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarOp::get_output_port_name(int p_port) const {
-	return "op"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeScalarOp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code = "\t" + p_output_vars[0] + " = ";
-	switch (op) {
-		case OP_ADD:
-			code += p_input_vars[0] + " + " + p_input_vars[1] + ";\n";
-			break;
-		case OP_SUB:
-			code += p_input_vars[0] + " - " + p_input_vars[1] + ";\n";
-			break;
-		case OP_MUL:
-			code += p_input_vars[0] + " * " + p_input_vars[1] + ";\n";
-			break;
-		case OP_DIV:
-			code += p_input_vars[0] + " / " + p_input_vars[1] + ";\n";
-			break;
-		case OP_MOD:
-			code += "mod(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_POW:
-			code += "pow(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_MAX:
-			code += "max(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_MIN:
-			code += "min(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_ATAN2:
-			code += "atan(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_STEP:
-			code += "step(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-	}
-
-	return code;
-}
-
-void VisualShaderNodeScalarOp::set_operator(Operator p_op) {
-	op = p_op;
-	emit_changed();
-}
-
-VisualShaderNodeScalarOp::Operator VisualShaderNodeScalarOp::get_operator() const {
-	return op;
-}
-
-Vector<StringName> VisualShaderNodeScalarOp::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("operator");
-	return props;
-}
-
-void VisualShaderNodeScalarOp::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeScalarOp::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeScalarOp::get_operator);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "Add,Sub,Multiply,Divide,Remainder,Power,Max,Min,Atan2,Step"), "set_operator", "get_operator");
-
-	BIND_ENUM_CONSTANT(OP_ADD);
-	BIND_ENUM_CONSTANT(OP_SUB);
-	BIND_ENUM_CONSTANT(OP_MUL);
-	BIND_ENUM_CONSTANT(OP_DIV);
-	BIND_ENUM_CONSTANT(OP_MOD);
-	BIND_ENUM_CONSTANT(OP_POW);
-	BIND_ENUM_CONSTANT(OP_MAX);
-	BIND_ENUM_CONSTANT(OP_MIN);
-	BIND_ENUM_CONSTANT(OP_ATAN2);
-	BIND_ENUM_CONSTANT(OP_STEP);
-}
-
-VisualShaderNodeScalarOp::VisualShaderNodeScalarOp() {
-	op = OP_ADD;
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-}
-
-////////////// Vector Op
-
-String VisualShaderNodeVectorOp::get_caption() const {
-	return "VectorOp";
-}
-
-int VisualShaderNodeVectorOp::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeVectorOp::PortType VisualShaderNodeVectorOp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorOp::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeVectorOp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorOp::PortType VisualShaderNodeVectorOp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorOp::get_output_port_name(int p_port) const {
-	return "op"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeVectorOp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code = "\t" + p_output_vars[0] + " = ";
-	switch (op) {
-		case OP_ADD:
-			code += p_input_vars[0] + " + " + p_input_vars[1] + ";\n";
-			break;
-		case OP_SUB:
-			code += p_input_vars[0] + " - " + p_input_vars[1] + ";\n";
-			break;
-		case OP_MUL:
-			code += p_input_vars[0] + " * " + p_input_vars[1] + ";\n";
-			break;
-		case OP_DIV:
-			code += p_input_vars[0] + " / " + p_input_vars[1] + ";\n";
-			break;
-		case OP_MOD:
-			code += "mod(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_POW:
-			code += "pow(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_MAX:
-			code += "max(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_MIN:
-			code += "min(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_CROSS:
-			code += "cross(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_ATAN2:
-			code += "atan(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_REFLECT:
-			code += "reflect(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-		case OP_STEP:
-			code += "step(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-			break;
-	}
-
-	return code;
-}
-
-void VisualShaderNodeVectorOp::set_operator(Operator p_op) {
-	op = p_op;
-	emit_changed();
-}
-
-VisualShaderNodeVectorOp::Operator VisualShaderNodeVectorOp::get_operator() const {
-	return op;
-}
-
-Vector<StringName> VisualShaderNodeVectorOp::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("operator");
-	return props;
-}
-
-void VisualShaderNodeVectorOp::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeVectorOp::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeVectorOp::get_operator);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "Add,Sub,Multiply,Divide,Remainder,Power,Max,Min,Cross,Atan2,Reflect,Step"), "set_operator", "get_operator");
-
-	BIND_ENUM_CONSTANT(OP_ADD);
-	BIND_ENUM_CONSTANT(OP_SUB);
-	BIND_ENUM_CONSTANT(OP_MUL);
-	BIND_ENUM_CONSTANT(OP_DIV);
-	BIND_ENUM_CONSTANT(OP_MOD);
-	BIND_ENUM_CONSTANT(OP_POW);
-	BIND_ENUM_CONSTANT(OP_MAX);
-	BIND_ENUM_CONSTANT(OP_MIN);
-	BIND_ENUM_CONSTANT(OP_CROSS);
-	BIND_ENUM_CONSTANT(OP_ATAN2);
-	BIND_ENUM_CONSTANT(OP_REFLECT);
-	BIND_ENUM_CONSTANT(OP_STEP);
-}
-
-VisualShaderNodeVectorOp::VisualShaderNodeVectorOp() {
-	op = OP_ADD;
-	set_input_port_default_value(0, Vector3());
-	set_input_port_default_value(1, Vector3());
-}
-
-////////////// Color Op
-
-String VisualShaderNodeColorOp::get_caption() const {
-	return "ColorOp";
-}
-
-int VisualShaderNodeColorOp::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeColorOp::PortType VisualShaderNodeColorOp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorOp::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeColorOp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeColorOp::PortType VisualShaderNodeColorOp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorOp::get_output_port_name(int p_port) const {
-	return "op"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeColorOp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	static const char *axisn[3] = { "x", "y", "z" };
-	switch (op) {
-		case OP_SCREEN: {
-			code += "\t" + p_output_vars[0] + " = vec3(1.0) - (vec3(1.0) - " + p_input_vars[0] + ") * (vec3(1.0) - " + p_input_vars[1] + ");\n";
-		} break;
-		case OP_DIFFERENCE: {
-			code += "\t" + p_output_vars[0] + " = abs(" + p_input_vars[0] + " - " + p_input_vars[1] + ");\n";
-		} break;
-		case OP_DARKEN: {
-			code += "\t" + p_output_vars[0] + " = min(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-		} break;
-		case OP_LIGHTEN: {
-			code += "\t" + p_output_vars[0] + " = max(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-
-		} break;
-		case OP_OVERLAY: {
-			for (int i = 0; i < 3; i++) {
-				code += "\t{\n";
-				code += "\t\tfloat base = " + p_input_vars[0] + "." + axisn[i] + ";\n";
-				code += "\t\tfloat blend = " + p_input_vars[1] + "." + axisn[i] + ";\n";
-				code += "\t\tif (base < 0.5) {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = 2.0 * base * blend;\n";
-				code += "\t\t} else {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = 1.0 - 2.0 * (1.0 - blend) * (1.0 - base);\n";
-				code += "\t\t}\n";
-				code += "\t}\n";
-			}
-
-		} break;
-		case OP_DODGE: {
-			code += "\t" + p_output_vars[0] + " = (" + p_input_vars[0] + ") / (vec3(1.0) - " + p_input_vars[1] + ");\n";
-
-		} break;
-		case OP_BURN: {
-			code += "\t" + p_output_vars[0] + " = vec3(1.0) - (vec3(1.0) - " + p_input_vars[0] + ") / (" + p_input_vars[1] + ");\n";
-		} break;
-		case OP_SOFT_LIGHT: {
-			for (int i = 0; i < 3; i++) {
-				code += "\t{\n";
-				code += "\t\tfloat base = " + p_input_vars[0] + "." + axisn[i] + ";\n";
-				code += "\t\tfloat blend = " + p_input_vars[1] + "." + axisn[i] + ";\n";
-				code += "\t\tif (base < 0.5) {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = (base * (blend + 0.5));\n";
-				code += "\t\t} else {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = (1.0 - (1.0 - base) * (1.0 - (blend - 0.5)));\n";
-				code += "\t\t}\n";
-				code += "\t}\n";
-			}
-
-		} break;
-		case OP_HARD_LIGHT: {
-			for (int i = 0; i < 3; i++) {
-				code += "\t{\n";
-				code += "\t\tfloat base = " + p_input_vars[0] + "." + axisn[i] + ";\n";
-				code += "\t\tfloat blend = " + p_input_vars[1] + "." + axisn[i] + ";\n";
-				code += "\t\tif (base < 0.5) {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = (base * (2.0 * blend));\n";
-				code += "\t\t} else {\n";
-				code += "\t\t\t" + p_output_vars[0] + "." + axisn[i] + " = (1.0 - (1.0 - base) * (1.0 - 2.0 * (blend - 0.5)));\n";
-				code += "\t\t}\n";
-				code += "\t}\n";
-			}
-
-		} break;
-	}
-
-	return code;
-}
-
-void VisualShaderNodeColorOp::set_operator(Operator p_op) {
-	op = p_op;
-	switch (op) {
-		case OP_SCREEN:
-			simple_decl = true;
-			break;
-		case OP_DIFFERENCE:
-			simple_decl = true;
-			break;
-		case OP_DARKEN:
-			simple_decl = true;
-			break;
-		case OP_LIGHTEN:
-			simple_decl = true;
-			break;
-		case OP_OVERLAY:
-			simple_decl = false;
-			break;
-		case OP_DODGE:
-			simple_decl = true;
-			break;
-		case OP_BURN:
-			simple_decl = true;
-			break;
-		case OP_SOFT_LIGHT:
-			simple_decl = false;
-			break;
-		case OP_HARD_LIGHT:
-			simple_decl = false;
-			break;
-	}
-	emit_changed();
-}
-
-VisualShaderNodeColorOp::Operator VisualShaderNodeColorOp::get_operator() const {
-	return op;
-}
-
-Vector<StringName> VisualShaderNodeColorOp::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("operator");
-	return props;
-}
-
-void VisualShaderNodeColorOp::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeColorOp::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeColorOp::get_operator);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "Screen,Difference,Darken,Lighten,Overlay,Dodge,Burn,SoftLight,HardLight"), "set_operator", "get_operator");
-
-	BIND_ENUM_CONSTANT(OP_SCREEN);
-	BIND_ENUM_CONSTANT(OP_DIFFERENCE);
-	BIND_ENUM_CONSTANT(OP_DARKEN);
-	BIND_ENUM_CONSTANT(OP_LIGHTEN);
-	BIND_ENUM_CONSTANT(OP_OVERLAY);
-	BIND_ENUM_CONSTANT(OP_DODGE);
-	BIND_ENUM_CONSTANT(OP_BURN);
-	BIND_ENUM_CONSTANT(OP_SOFT_LIGHT);
-	BIND_ENUM_CONSTANT(OP_HARD_LIGHT);
-}
-
-VisualShaderNodeColorOp::VisualShaderNodeColorOp() {
-	op = OP_SCREEN;
-	set_input_port_default_value(0, Vector3());
-	set_input_port_default_value(1, Vector3());
-}
-
-////////////// Transform Mult
-
-String VisualShaderNodeTransformMult::get_caption() const {
-	return "TransformMult";
-}
-
-int VisualShaderNodeTransformMult::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeTransformMult::PortType VisualShaderNodeTransformMult::get_input_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformMult::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeTransformMult::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformMult::PortType VisualShaderNodeTransformMult::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformMult::get_output_port_name(int p_port) const {
-	return "mult"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeTransformMult::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	if (op == OP_AxB) {
-		return "\t" + p_output_vars[0] + " = " + p_input_vars[0] + " * " + p_input_vars[1] + ";\n";
-	} else if (op == OP_BxA) {
-		return "\t" + p_output_vars[0] + " = " + p_input_vars[1] + " * " + p_input_vars[0] + ";\n";
-	} else if (op == OP_AxB_COMP) {
-		return "\t" + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-	} else {
-		return "\t" + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[1] + ", " + p_input_vars[0] + ");\n";
-	}
-}
-
-void VisualShaderNodeTransformMult::set_operator(Operator p_op) {
-	op = p_op;
-	emit_changed();
-}
-
-VisualShaderNodeTransformMult::Operator VisualShaderNodeTransformMult::get_operator() const {
-	return op;
-}
-
-Vector<StringName> VisualShaderNodeTransformMult::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("operator");
-	return props;
-}
-
-void VisualShaderNodeTransformMult::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeTransformMult::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeTransformMult::get_operator);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "A x B,B x A,A x B(per component),B x A(per component)"), "set_operator", "get_operator");
-
-	BIND_ENUM_CONSTANT(OP_AxB);
-	BIND_ENUM_CONSTANT(OP_BxA);
-	BIND_ENUM_CONSTANT(OP_AxB_COMP);
-	BIND_ENUM_CONSTANT(OP_BxA_COMP);
-}
-
-VisualShaderNodeTransformMult::VisualShaderNodeTransformMult() {
-	op = OP_AxB;
-	set_input_port_default_value(0, Transform());
-	set_input_port_default_value(1, Transform());
-}
-
-////////////// TransformVec Mult
-
-String VisualShaderNodeTransformVecMult::get_caption() const {
-	return "TransformVectorMult";
-}
-
-int VisualShaderNodeTransformVecMult::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeTransformVecMult::PortType VisualShaderNodeTransformVecMult::get_input_port_type(int p_port) const {
-	return p_port == 0 ? PORT_TYPE_TRANSFORM : PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformVecMult::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeTransformVecMult::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformVecMult::PortType VisualShaderNodeTransformVecMult::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformVecMult::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeTransformVecMult::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	if (op == OP_AxB) {
-		return "\t" + p_output_vars[0] + " = (" + p_input_vars[0] + " * vec4(" + p_input_vars[1] + ", 1.0)).xyz;\n";
-	} else if (op == OP_BxA) {
-		return "\t" + p_output_vars[0] + " = (vec4(" + p_input_vars[1] + ", 1.0) * " + p_input_vars[0] + ").xyz;\n";
-	} else if (op == OP_3x3_AxB) {
-		return "\t" + p_output_vars[0] + " = (" + p_input_vars[0] + " * vec4(" + p_input_vars[1] + ", 0.0)).xyz;\n";
-	} else {
-		return "\t" + p_output_vars[0] + " = (vec4(" + p_input_vars[1] + ", 0.0) * " + p_input_vars[0] + ").xyz;\n";
-	}
-}
-
-void VisualShaderNodeTransformVecMult::set_operator(Operator p_op) {
-	op = p_op;
-	emit_changed();
-}
-
-VisualShaderNodeTransformVecMult::Operator VisualShaderNodeTransformVecMult::get_operator() const {
-	return op;
-}
-
-Vector<StringName> VisualShaderNodeTransformVecMult::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("operator");
-	return props;
-}
-
-void VisualShaderNodeTransformVecMult::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeTransformVecMult::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeTransformVecMult::get_operator);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "A x B,B x A,A x B (3x3),B x A (3x3)"), "set_operator", "get_operator");
-
-	BIND_ENUM_CONSTANT(OP_AxB);
-	BIND_ENUM_CONSTANT(OP_BxA);
-	BIND_ENUM_CONSTANT(OP_3x3_AxB);
-	BIND_ENUM_CONSTANT(OP_3x3_BxA);
-}
-
-VisualShaderNodeTransformVecMult::VisualShaderNodeTransformVecMult() {
-	op = OP_AxB;
-	set_input_port_default_value(0, Transform());
-	set_input_port_default_value(1, Vector3());
-}
-
-////////////// Scalar Func
-
-String VisualShaderNodeScalarFunc::get_caption() const {
-	return "ScalarFunc";
-}
-
-int VisualShaderNodeScalarFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarFunc::PortType VisualShaderNodeScalarFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeScalarFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarFunc::PortType VisualShaderNodeScalarFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarFunc::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeScalarFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *scalar_func_id[FUNC_ONEMINUS + 1] = {
-		"sin($)",
-		"cos($)",
-		"tan($)",
-		"asin($)",
-		"acos($)",
-		"atan($)",
-		"sinh($)",
-		"cosh($)",
-		"tanh($)",
-		"log($)",
-		"exp($)",
-		"sqrt($)",
-		"abs($)",
-		"sign($)",
-		"floor($)",
-		"round($)",
-		"ceil($)",
-		"fract($)",
-		"min(max($, 0.0), 1.0)",
-		"-($)",
-		"acosh($)",
-		"asinh($)",
-		"atanh($)",
-		"degrees($)",
-		"exp2($)",
-		"inversesqrt($)",
-		"log2($)",
-		"radians($)",
-		"1.0 / ($)",
-		"roundEven($)",
-		"trunc($)",
-		"1.0 - $"
-	};
-
-	return "\t" + p_output_vars[0] + " = " + String(scalar_func_id[func]).replace("$", p_input_vars[0]) + ";\n";
-}
-
-void VisualShaderNodeScalarFunc::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeScalarFunc::Function VisualShaderNodeScalarFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeScalarFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeScalarFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeScalarFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeScalarFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Sin,Cos,Tan,ASin,ACos,ATan,SinH,CosH,TanH,Log,Exp,Sqrt,Abs,Sign,Floor,Round,Ceil,Frac,Saturate,Negate,ACosH,ASinH,ATanH,Degrees,Exp2,InverseSqrt,Log2,Radians,Reciprocal,RoundEven,Trunc,OneMinus"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_SIN);
-	BIND_ENUM_CONSTANT(FUNC_COS);
-	BIND_ENUM_CONSTANT(FUNC_TAN);
-	BIND_ENUM_CONSTANT(FUNC_ASIN);
-	BIND_ENUM_CONSTANT(FUNC_ACOS);
-	BIND_ENUM_CONSTANT(FUNC_ATAN);
-	BIND_ENUM_CONSTANT(FUNC_SINH);
-	BIND_ENUM_CONSTANT(FUNC_COSH);
-	BIND_ENUM_CONSTANT(FUNC_TANH);
-	BIND_ENUM_CONSTANT(FUNC_LOG);
-	BIND_ENUM_CONSTANT(FUNC_EXP);
-	BIND_ENUM_CONSTANT(FUNC_SQRT);
-	BIND_ENUM_CONSTANT(FUNC_ABS);
-	BIND_ENUM_CONSTANT(FUNC_SIGN);
-	BIND_ENUM_CONSTANT(FUNC_FLOOR);
-	BIND_ENUM_CONSTANT(FUNC_ROUND);
-	BIND_ENUM_CONSTANT(FUNC_CEIL);
-	BIND_ENUM_CONSTANT(FUNC_FRAC);
-	BIND_ENUM_CONSTANT(FUNC_SATURATE);
-	BIND_ENUM_CONSTANT(FUNC_NEGATE);
-	BIND_ENUM_CONSTANT(FUNC_ACOSH);
-	BIND_ENUM_CONSTANT(FUNC_ASINH);
-	BIND_ENUM_CONSTANT(FUNC_ATANH);
-	BIND_ENUM_CONSTANT(FUNC_DEGREES);
-	BIND_ENUM_CONSTANT(FUNC_EXP2);
-	BIND_ENUM_CONSTANT(FUNC_INVERSE_SQRT);
-	BIND_ENUM_CONSTANT(FUNC_LOG2);
-	BIND_ENUM_CONSTANT(FUNC_RADIANS);
-	BIND_ENUM_CONSTANT(FUNC_RECIPROCAL);
-	BIND_ENUM_CONSTANT(FUNC_ROUNDEVEN);
-	BIND_ENUM_CONSTANT(FUNC_TRUNC);
-	BIND_ENUM_CONSTANT(FUNC_ONEMINUS);
-}
-
-VisualShaderNodeScalarFunc::VisualShaderNodeScalarFunc() {
-	func = FUNC_SIGN;
-	set_input_port_default_value(0, 0.0);
-}
-
-////////////// Vector Func
-
-String VisualShaderNodeVectorFunc::get_caption() const {
-	return "VectorFunc";
-}
-
-int VisualShaderNodeVectorFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorFunc::PortType VisualShaderNodeVectorFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeVectorFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorFunc::PortType VisualShaderNodeVectorFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorFunc::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeVectorFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *vec_func_id[FUNC_ONEMINUS + 1] = {
-		"normalize($)",
-		"max(min($, vec3(1.0)), vec3(0.0))",
-		"-($)",
-		"1.0 / ($)",
-		"",
-		"",
-		"abs($)",
-		"acos($)",
-		"acosh($)",
-		"asin($)",
-		"asinh($)",
-		"atan($)",
-		"atanh($)",
-		"ceil($)",
-		"cos($)",
-		"cosh($)",
-		"degrees($)",
-		"exp($)",
-		"exp2($)",
-		"floor($)",
-		"fract($)",
-		"inversesqrt($)",
-		"log($)",
-		"log2($)",
-		"radians($)",
-		"round($)",
-		"roundEven($)",
-		"sign($)",
-		"sin($)",
-		"sinh($)",
-		"sqrt($)",
-		"tan($)",
-		"tanh($)",
-		"trunc($)",
-		"vec3(1.0, 1.0, 1.0) - $"
-	};
-
-	String code;
-
-	if (func == FUNC_RGB2HSV) {
-		code += "\t{\n";
-		code += "\t\tvec3 c = " + p_input_vars[0] + ";\n";
-		code += "\t\tvec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n";
-		code += "\t\tvec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n";
-		code += "\t\tvec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n";
-		code += "\t\tfloat d = q.x - min(q.w, q.y);\n";
-		code += "\t\tfloat e = 1.0e-10;\n";
-		code += "\t\t" + p_output_vars[0] + " = vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n";
-		code += "\t}\n";
-	} else if (func == FUNC_HSV2RGB) {
-		code += "\t{\n";
-		code += "\t\tvec3 c = " + p_input_vars[0] + ";\n";
-		code += "\t\tvec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n";
-		code += "\t\tvec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n";
-		code += "\t\t" + p_output_vars[0] + " = c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n";
-		code += "\t}\n";
-
-	} else {
-		code += "\t" + p_output_vars[0] + " = " + String(vec_func_id[func]).replace("$", p_input_vars[0]) + ";\n";
-	}
-
-	return code;
-}
-
-void VisualShaderNodeVectorFunc::set_function(Function p_func) {
-	func = p_func;
-	if (func == FUNC_RGB2HSV) {
-		simple_decl = false;
-	} else if (func == FUNC_HSV2RGB) {
-		simple_decl = false;
-	} else {
-		simple_decl = true;
-	}
-	emit_changed();
-}
-
-VisualShaderNodeVectorFunc::Function VisualShaderNodeVectorFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeVectorFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeVectorFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeVectorFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeVectorFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Normalize,Saturate,Negate,Reciprocal,RGB2HSV,HSV2RGB,Abs,ACos,ACosH,ASin,ASinH,ATan,ATanH,Ceil,Cos,CosH,Degrees,Exp,Exp2,Floor,Frac,InverseSqrt,Log,Log2,Radians,Round,RoundEven,Sign,Sin,SinH,Sqrt,Tan,TanH,Trunc,OneMinus"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_NORMALIZE);
-	BIND_ENUM_CONSTANT(FUNC_SATURATE);
-	BIND_ENUM_CONSTANT(FUNC_NEGATE);
-	BIND_ENUM_CONSTANT(FUNC_RECIPROCAL);
-	BIND_ENUM_CONSTANT(FUNC_RGB2HSV);
-	BIND_ENUM_CONSTANT(FUNC_HSV2RGB);
-	BIND_ENUM_CONSTANT(FUNC_ABS);
-	BIND_ENUM_CONSTANT(FUNC_ACOS);
-	BIND_ENUM_CONSTANT(FUNC_ACOSH);
-	BIND_ENUM_CONSTANT(FUNC_ASIN);
-	BIND_ENUM_CONSTANT(FUNC_ASINH);
-	BIND_ENUM_CONSTANT(FUNC_ATAN);
-	BIND_ENUM_CONSTANT(FUNC_ATANH);
-	BIND_ENUM_CONSTANT(FUNC_CEIL);
-	BIND_ENUM_CONSTANT(FUNC_COS);
-	BIND_ENUM_CONSTANT(FUNC_COSH);
-	BIND_ENUM_CONSTANT(FUNC_DEGREES);
-	BIND_ENUM_CONSTANT(FUNC_EXP);
-	BIND_ENUM_CONSTANT(FUNC_EXP2);
-	BIND_ENUM_CONSTANT(FUNC_FLOOR);
-	BIND_ENUM_CONSTANT(FUNC_FRAC);
-	BIND_ENUM_CONSTANT(FUNC_INVERSE_SQRT);
-	BIND_ENUM_CONSTANT(FUNC_LOG);
-	BIND_ENUM_CONSTANT(FUNC_LOG2);
-	BIND_ENUM_CONSTANT(FUNC_RADIANS);
-	BIND_ENUM_CONSTANT(FUNC_ROUND);
-	BIND_ENUM_CONSTANT(FUNC_ROUNDEVEN);
-	BIND_ENUM_CONSTANT(FUNC_SIGN);
-	BIND_ENUM_CONSTANT(FUNC_SIN);
-	BIND_ENUM_CONSTANT(FUNC_SINH);
-	BIND_ENUM_CONSTANT(FUNC_SQRT);
-	BIND_ENUM_CONSTANT(FUNC_TAN);
-	BIND_ENUM_CONSTANT(FUNC_TANH);
-	BIND_ENUM_CONSTANT(FUNC_TRUNC);
-	BIND_ENUM_CONSTANT(FUNC_ONEMINUS);
-}
-
-VisualShaderNodeVectorFunc::VisualShaderNodeVectorFunc() {
-	func = FUNC_NORMALIZE;
-	set_input_port_default_value(0, Vector3());
-}
-
-////////////// ColorFunc
-
-String VisualShaderNodeColorFunc::get_caption() const {
-	return "ColorFunc";
-}
-
-int VisualShaderNodeColorFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeColorFunc::PortType VisualShaderNodeColorFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeColorFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeColorFunc::PortType VisualShaderNodeColorFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorFunc::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeColorFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-
-	switch (func) {
-		case FUNC_GRAYSCALE:
-			code += "\t{\n";
-			code += "\t\tvec3 c = " + p_input_vars[0] + ";\n";
-			code += "\t\tfloat max1 = max(c.r, c.g);\n";
-			code += "\t\tfloat max2 = max(max1, c.b);\n";
-			code += "\t\t" + p_output_vars[0] + " = vec3(max2, max2, max2);\n";
-			code += "\t}\n";
-			break;
-		case FUNC_SEPIA:
-			code += "\t{\n";
-			code += "\t\tvec3 c = " + p_input_vars[0] + ";\n";
-			code += "\t\tfloat r = (c.r * .393) + (c.g *.769) + (c.b * .189);\n";
-			code += "\t\tfloat g = (c.r * .349) + (c.g *.686) + (c.b * .168);\n";
-			code += "\t\tfloat b = (c.r * .272) + (c.g *.534) + (c.b * .131);\n";
-			code += "\t\t" + p_output_vars[0] + " = vec3(r, g, b);\n";
-			code += "\t}\n";
-			break;
-	}
-
-	return code;
-}
-
-void VisualShaderNodeColorFunc::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeColorFunc::Function VisualShaderNodeColorFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeColorFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeColorFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeColorFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeColorFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Grayscale,Sepia"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_GRAYSCALE);
-	BIND_ENUM_CONSTANT(FUNC_SEPIA);
-}
-
-VisualShaderNodeColorFunc::VisualShaderNodeColorFunc() {
-	func = FUNC_GRAYSCALE;
-	set_input_port_default_value(0, Vector3());
-	simple_decl = false;
-}
-
-////////////// Transform Func
-
-String VisualShaderNodeTransformFunc::get_caption() const {
-	return "TransformFunc";
-}
-
-int VisualShaderNodeTransformFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformFunc::PortType VisualShaderNodeTransformFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeTransformFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformFunc::PortType VisualShaderNodeTransformFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformFunc::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeTransformFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *funcs[FUNC_TRANSPOSE + 1] = {
-		"inverse($)",
-		"transpose($)"
-	};
-
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + String(funcs[func]).replace("$", p_input_vars[0]) + ";\n";
-	return code;
-}
-
-void VisualShaderNodeTransformFunc::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeTransformFunc::Function VisualShaderNodeTransformFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeTransformFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeTransformFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeTransformFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeTransformFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Inverse,Transpose"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_INVERSE);
-	BIND_ENUM_CONSTANT(FUNC_TRANSPOSE);
-}
-
-VisualShaderNodeTransformFunc::VisualShaderNodeTransformFunc() {
-	func = FUNC_INVERSE;
-	set_input_port_default_value(0, Transform());
-}
-
-////////////// Dot Product
-
-String VisualShaderNodeDotProduct::get_caption() const {
-	return "DotProduct";
-}
-
-int VisualShaderNodeDotProduct::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeDotProduct::PortType VisualShaderNodeDotProduct::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeDotProduct::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "a" : "b";
-}
-
-int VisualShaderNodeDotProduct::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeDotProduct::PortType VisualShaderNodeDotProduct::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeDotProduct::get_output_port_name(int p_port) const {
-	return "dot";
-}
-
-String VisualShaderNodeDotProduct::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = dot(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-}
-
-VisualShaderNodeDotProduct::VisualShaderNodeDotProduct() {
-	set_input_port_default_value(0, Vector3());
-	set_input_port_default_value(1, Vector3());
-}
-
-////////////// Vector Len
-
-String VisualShaderNodeVectorLen::get_caption() const {
-	return "VectorLen";
-}
-
-int VisualShaderNodeVectorLen::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorLen::PortType VisualShaderNodeVectorLen::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorLen::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeVectorLen::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorLen::PortType VisualShaderNodeVectorLen::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeVectorLen::get_output_port_name(int p_port) const {
-	return "length";
-}
-
-String VisualShaderNodeVectorLen::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = length(" + p_input_vars[0] + ");\n";
-}
-
-VisualShaderNodeVectorLen::VisualShaderNodeVectorLen() {
-	set_input_port_default_value(0, Vector3());
-}
-
-////////////// Determinant
-
-String VisualShaderNodeDeterminant::get_caption() const {
-	return "Determinant";
-}
-
-int VisualShaderNodeDeterminant::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeDeterminant::PortType VisualShaderNodeDeterminant::get_input_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeDeterminant::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeDeterminant::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeDeterminant::PortType VisualShaderNodeDeterminant::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeDeterminant::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeDeterminant::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = determinant(" + p_input_vars[0] + ");\n";
-}
-
-VisualShaderNodeDeterminant::VisualShaderNodeDeterminant() {
-	set_input_port_default_value(0, Transform());
-}
-
-////////////// Scalar Derivative Function
-
-String VisualShaderNodeScalarDerivativeFunc::get_caption() const {
-	return "ScalarDerivativeFunc";
-}
-
-int VisualShaderNodeScalarDerivativeFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarDerivativeFunc::PortType VisualShaderNodeScalarDerivativeFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarDerivativeFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeScalarDerivativeFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarDerivativeFunc::PortType VisualShaderNodeScalarDerivativeFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarDerivativeFunc::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeScalarDerivativeFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *funcs[FUNC_Y + 1] = {
-		"fwidth($)",
-		"dFdx($)",
-		"dFdy($)"
-	};
-
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + String(funcs[func]).replace("$", p_input_vars[0]) + ";\n";
-	return code;
-}
-
-void VisualShaderNodeScalarDerivativeFunc::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeScalarDerivativeFunc::Function VisualShaderNodeScalarDerivativeFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeScalarDerivativeFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeScalarDerivativeFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeScalarDerivativeFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeScalarDerivativeFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Sum,X,Y"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_SUM);
-	BIND_ENUM_CONSTANT(FUNC_X);
-	BIND_ENUM_CONSTANT(FUNC_Y);
-}
-
-VisualShaderNodeScalarDerivativeFunc::VisualShaderNodeScalarDerivativeFunc() {
-	func = FUNC_SUM;
-	set_input_port_default_value(0, 0.0);
-}
-
-////////////// Vector Derivative Function
-
-String VisualShaderNodeVectorDerivativeFunc::get_caption() const {
-	return "VectorDerivativeFunc";
-}
-
-int VisualShaderNodeVectorDerivativeFunc::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorDerivativeFunc::PortType VisualShaderNodeVectorDerivativeFunc::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorDerivativeFunc::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeVectorDerivativeFunc::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorDerivativeFunc::PortType VisualShaderNodeVectorDerivativeFunc::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorDerivativeFunc::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorDerivativeFunc::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *funcs[FUNC_Y + 1] = {
-		"fwidth($)",
-		"dFdx($)",
-		"dFdy($)"
-	};
-
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + String(funcs[func]).replace("$", p_input_vars[0]) + ";\n";
-	return code;
-}
-
-void VisualShaderNodeVectorDerivativeFunc::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeVectorDerivativeFunc::Function VisualShaderNodeVectorDerivativeFunc::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeVectorDerivativeFunc::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeVectorDerivativeFunc::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeVectorDerivativeFunc::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeVectorDerivativeFunc::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Sum,X,Y"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_SUM);
-	BIND_ENUM_CONSTANT(FUNC_X);
-	BIND_ENUM_CONSTANT(FUNC_Y);
-}
-
-VisualShaderNodeVectorDerivativeFunc::VisualShaderNodeVectorDerivativeFunc() {
-	func = FUNC_SUM;
-	set_input_port_default_value(0, Vector3());
-}
-
-////////////// Scalar Clamp
-
-String VisualShaderNodeScalarClamp::get_caption() const {
-	return "ScalarClamp";
-}
-
-int VisualShaderNodeScalarClamp::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeScalarClamp::PortType VisualShaderNodeScalarClamp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarClamp::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "";
-	} else if (p_port == 1) {
-		return "min";
-	} else if (p_port == 2) {
-		return "max";
-	}
-	return "";
-}
-
-int VisualShaderNodeScalarClamp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarClamp::PortType VisualShaderNodeScalarClamp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarClamp::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeScalarClamp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = clamp(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeScalarClamp::VisualShaderNodeScalarClamp() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, 1.0);
-}
-
-////////////// Vector Clamp
-
-String VisualShaderNodeVectorClamp::get_caption() const {
-	return "VectorClamp";
-}
-
-int VisualShaderNodeVectorClamp::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorClamp::PortType VisualShaderNodeVectorClamp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorClamp::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "";
-	} else if (p_port == 1) {
-		return "min";
-	} else if (p_port == 2) {
-		return "max";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorClamp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorClamp::PortType VisualShaderNodeVectorClamp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorClamp::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorClamp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = clamp(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorClamp::VisualShaderNodeVectorClamp() {
-	set_input_port_default_value(0, Vector3(0, 0, 0));
-	set_input_port_default_value(1, Vector3(0, 0, 0));
-	set_input_port_default_value(2, Vector3(1, 1, 1));
-}
-
-////////////// FaceForward
-
-String VisualShaderNodeFaceForward::get_caption() const {
-	return "FaceForward";
-}
-
-int VisualShaderNodeFaceForward::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeFaceForward::PortType VisualShaderNodeFaceForward::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeFaceForward::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "N";
-		case 1:
-			return "I";
-		case 2:
-			return "Nref";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeFaceForward::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeFaceForward::PortType VisualShaderNodeFaceForward::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeFaceForward::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeFaceForward::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = faceforward(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeFaceForward::VisualShaderNodeFaceForward() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Outer Product
-
-String VisualShaderNodeOuterProduct::get_caption() const {
-	return "OuterProduct";
-}
-
-int VisualShaderNodeOuterProduct::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeOuterProduct::PortType VisualShaderNodeOuterProduct::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeOuterProduct::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "c";
-		case 1:
-			return "r";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeOuterProduct::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeOuterProduct::PortType VisualShaderNodeOuterProduct::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeOuterProduct::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeOuterProduct::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = outerProduct(vec4(" + p_input_vars[0] + ", 0.0), vec4(" + p_input_vars[1] + ", 0.0));\n";
-}
-
-VisualShaderNodeOuterProduct::VisualShaderNodeOuterProduct() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Vector-Scalar Step
-
-String VisualShaderNodeVectorScalarStep::get_caption() const {
-	return "VectorScalarStep";
-}
-
-int VisualShaderNodeVectorScalarStep::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeVectorScalarStep::PortType VisualShaderNodeVectorScalarStep::get_input_port_type(int p_port) const {
-	if (p_port == 0) {
-		return PORT_TYPE_SCALAR;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarStep::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "edge";
-	} else if (p_port == 1) {
-		return "x";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorScalarStep::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorScalarStep::PortType VisualShaderNodeVectorScalarStep::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarStep::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorScalarStep::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = step(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-}
-
-VisualShaderNodeVectorScalarStep::VisualShaderNodeVectorScalarStep() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Scalar SmoothStep
-
-String VisualShaderNodeScalarSmoothStep::get_caption() const {
-	return "ScalarSmoothStep";
-}
-
-int VisualShaderNodeScalarSmoothStep::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeScalarSmoothStep::PortType VisualShaderNodeScalarSmoothStep::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarSmoothStep::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "edge0";
-	} else if (p_port == 1) {
-		return "edge1";
-	} else if (p_port == 2) {
-		return "x";
-	}
-	return "";
-}
-
-int VisualShaderNodeScalarSmoothStep::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarSmoothStep::PortType VisualShaderNodeScalarSmoothStep::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarSmoothStep::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeScalarSmoothStep::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = smoothstep(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeScalarSmoothStep::VisualShaderNodeScalarSmoothStep() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, 0.0);
-}
-
-////////////// Vector SmoothStep
-
-String VisualShaderNodeVectorSmoothStep::get_caption() const {
-	return "VectorSmoothStep";
-}
-
-int VisualShaderNodeVectorSmoothStep::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorSmoothStep::PortType VisualShaderNodeVectorSmoothStep::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorSmoothStep::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "edge0";
-	} else if (p_port == 1) {
-		return "edge1";
-	} else if (p_port == 2) {
-		return "x";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorSmoothStep::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorSmoothStep::PortType VisualShaderNodeVectorSmoothStep::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorSmoothStep::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorSmoothStep::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = smoothstep(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorSmoothStep::VisualShaderNodeVectorSmoothStep() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Vector-Scalar SmoothStep
-
-String VisualShaderNodeVectorScalarSmoothStep::get_caption() const {
-	return "VectorScalarSmoothStep";
-}
-
-int VisualShaderNodeVectorScalarSmoothStep::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorScalarSmoothStep::PortType VisualShaderNodeVectorScalarSmoothStep::get_input_port_type(int p_port) const {
-	if (p_port == 0) {
-		return PORT_TYPE_SCALAR;
-	} else if (p_port == 1) {
-		return PORT_TYPE_SCALAR;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarSmoothStep::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "edge0";
-	} else if (p_port == 1) {
-		return "edge1";
-	} else if (p_port == 2) {
-		return "x";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorScalarSmoothStep::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorScalarSmoothStep::PortType VisualShaderNodeVectorScalarSmoothStep::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarSmoothStep::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorScalarSmoothStep::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = smoothstep(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorScalarSmoothStep::VisualShaderNodeVectorScalarSmoothStep() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Distance
-
-String VisualShaderNodeVectorDistance::get_caption() const {
-	return "Distance";
-}
-
-int VisualShaderNodeVectorDistance::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeVectorDistance::PortType VisualShaderNodeVectorDistance::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorDistance::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "p0";
-	} else if (p_port == 1) {
-		return "p1";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorDistance::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorDistance::PortType VisualShaderNodeVectorDistance::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeVectorDistance::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorDistance::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = distance(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
-}
-
-VisualShaderNodeVectorDistance::VisualShaderNodeVectorDistance() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-}
-
-////////////// Refract Vector
-
-String VisualShaderNodeVectorRefract::get_caption() const {
-	return "Refract";
-}
-
-int VisualShaderNodeVectorRefract::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorRefract::PortType VisualShaderNodeVectorRefract::get_input_port_type(int p_port) const {
-	if (p_port == 2) {
-		return PORT_TYPE_SCALAR;
-	}
-
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorRefract::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "I";
-	} else if (p_port == 1) {
-		return "N";
-	} else if (p_port == 2) {
-		return "eta";
-	}
-	return "";
-}
-
-int VisualShaderNodeVectorRefract::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorRefract::PortType VisualShaderNodeVectorRefract::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorRefract::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeVectorRefract::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = refract(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorRefract::VisualShaderNodeVectorRefract() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(2, 0.0);
-}
-
-////////////// Scalar Mix
-
-String VisualShaderNodeScalarInterp::get_caption() const {
-	return "ScalarMix";
-}
-
-int VisualShaderNodeScalarInterp::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeScalarInterp::PortType VisualShaderNodeScalarInterp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarInterp::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "a";
-	} else if (p_port == 1) {
-		return "b";
-	} else {
-		return "weight";
-	}
-}
-
-int VisualShaderNodeScalarInterp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarInterp::PortType VisualShaderNodeScalarInterp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarInterp::get_output_port_name(int p_port) const {
-	return "mix";
-}
-
-String VisualShaderNodeScalarInterp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = mix(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeScalarInterp::VisualShaderNodeScalarInterp() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 1.0);
-	set_input_port_default_value(2, 0.5);
-}
-
-////////////// Vector Mix
-
-String VisualShaderNodeVectorInterp::get_caption() const {
-	return "VectorMix";
-}
-
-int VisualShaderNodeVectorInterp::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorInterp::PortType VisualShaderNodeVectorInterp::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorInterp::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "a";
-	} else if (p_port == 1) {
-		return "b";
-	} else {
-		return "weight";
-	}
-}
-
-int VisualShaderNodeVectorInterp::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorInterp::PortType VisualShaderNodeVectorInterp::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorInterp::get_output_port_name(int p_port) const {
-	return "mix";
-}
-
-String VisualShaderNodeVectorInterp::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = mix(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorInterp::VisualShaderNodeVectorInterp() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(1.0, 1.0, 1.0));
-	set_input_port_default_value(2, Vector3(0.5, 0.5, 0.5));
-}
-
-////////////// Vector Mix (by scalar)
-
-String VisualShaderNodeVectorScalarMix::get_caption() const {
-	return "VectorScalarMix";
-}
-
-int VisualShaderNodeVectorScalarMix::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorScalarMix::PortType VisualShaderNodeVectorScalarMix::get_input_port_type(int p_port) const {
-	if (p_port == 2) {
-		return PORT_TYPE_SCALAR;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarMix::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "a";
-	} else if (p_port == 1) {
-		return "b";
-	} else {
-		return "weight";
-	}
-}
-
-int VisualShaderNodeVectorScalarMix::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorScalarMix::PortType VisualShaderNodeVectorScalarMix::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorScalarMix::get_output_port_name(int p_port) const {
-	return "mix";
-}
-
-String VisualShaderNodeVectorScalarMix::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = mix(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorScalarMix::VisualShaderNodeVectorScalarMix() {
-	set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(1, Vector3(1.0, 1.0, 1.0));
-	set_input_port_default_value(2, 0.5);
-}
-
-////////////// Vector Compose
-
-String VisualShaderNodeVectorCompose::get_caption() const {
-	return "VectorCompose";
-}
-
-int VisualShaderNodeVectorCompose::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorCompose::PortType VisualShaderNodeVectorCompose::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeVectorCompose::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "x";
-	} else if (p_port == 1) {
-		return "y";
-	} else {
-		return "z";
-	}
-}
-
-int VisualShaderNodeVectorCompose::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorCompose::PortType VisualShaderNodeVectorCompose::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorCompose::get_output_port_name(int p_port) const {
-	return "vec";
-}
-
-String VisualShaderNodeVectorCompose::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = vec3(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
-}
-
-VisualShaderNodeVectorCompose::VisualShaderNodeVectorCompose() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, 0.0);
-}
-
-////////////// Transform Compose
-
-String VisualShaderNodeTransformCompose::get_caption() const {
-	return "TransformCompose";
-}
-
-int VisualShaderNodeTransformCompose::get_input_port_count() const {
-	return 4;
-}
-
-VisualShaderNodeTransformCompose::PortType VisualShaderNodeTransformCompose::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformCompose::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "x";
-	} else if (p_port == 1) {
-		return "y";
-	} else if (p_port == 2) {
-		return "z";
-	} else {
-		return "origin";
-	}
-}
-
-int VisualShaderNodeTransformCompose::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformCompose::PortType VisualShaderNodeTransformCompose::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformCompose::get_output_port_name(int p_port) const {
-	return "xform";
-}
-
-String VisualShaderNodeTransformCompose::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = mat4(vec4(" + p_input_vars[0] + ", 0.0), vec4(" + p_input_vars[1] + ", 0.0), vec4(" + p_input_vars[2] + ", 0.0), vec4(" + p_input_vars[3] + ", 1.0));\n";
-}
-
-VisualShaderNodeTransformCompose::VisualShaderNodeTransformCompose() {
-	set_input_port_default_value(0, Vector3());
-	set_input_port_default_value(1, Vector3());
-	set_input_port_default_value(2, Vector3());
-	set_input_port_default_value(3, Vector3());
-}
-
-////////////// Vector Decompose
-String VisualShaderNodeVectorDecompose::get_caption() const {
-	return "VectorDecompose";
-}
-
-int VisualShaderNodeVectorDecompose::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVectorDecompose::PortType VisualShaderNodeVectorDecompose::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVectorDecompose::get_input_port_name(int p_port) const {
-	return "vec";
-}
-
-int VisualShaderNodeVectorDecompose::get_output_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeVectorDecompose::PortType VisualShaderNodeVectorDecompose::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeVectorDecompose::get_output_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "x";
-	} else if (p_port == 1) {
-		return "y";
-	} else {
-		return "z";
-	}
-}
-
-String VisualShaderNodeVectorDecompose::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + p_input_vars[0] + ".x;\n";
-	code += "\t" + p_output_vars[1] + " = " + p_input_vars[0] + ".y;\n";
-	code += "\t" + p_output_vars[2] + " = " + p_input_vars[0] + ".z;\n";
-	return code;
-}
-
-VisualShaderNodeVectorDecompose::VisualShaderNodeVectorDecompose() {
-	set_input_port_default_value(0, Vector3());
-}
-
-////////////// Transform Decompose
-
-String VisualShaderNodeTransformDecompose::get_caption() const {
-	return "TransformDecompose";
-}
-
-int VisualShaderNodeTransformDecompose::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformDecompose::PortType VisualShaderNodeTransformDecompose::get_input_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformDecompose::get_input_port_name(int p_port) const {
-	return "xform";
-}
-
-int VisualShaderNodeTransformDecompose::get_output_port_count() const {
-	return 4;
-}
-
-VisualShaderNodeTransformDecompose::PortType VisualShaderNodeTransformDecompose::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformDecompose::get_output_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "x";
-	} else if (p_port == 1) {
-		return "y";
-	} else if (p_port == 2) {
-		return "z";
-	} else {
-		return "origin";
-	}
-}
-
-String VisualShaderNodeTransformDecompose::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + p_input_vars[0] + "[0].xyz;\n";
-	code += "\t" + p_output_vars[1] + " = " + p_input_vars[0] + "[1].xyz;\n";
-	code += "\t" + p_output_vars[2] + " = " + p_input_vars[0] + "[2].xyz;\n";
-	code += "\t" + p_output_vars[3] + " = " + p_input_vars[0] + "[3].xyz;\n";
-	return code;
-}
-
-VisualShaderNodeTransformDecompose::VisualShaderNodeTransformDecompose() {
-	set_input_port_default_value(0, Transform());
-}
-
-////////////// Scalar Uniform
-
-String VisualShaderNodeScalarUniform::get_caption() const {
-	return "ScalarUniform";
-}
-
-int VisualShaderNodeScalarUniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeScalarUniform::PortType VisualShaderNodeScalarUniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarUniform::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeScalarUniform::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeScalarUniform::PortType VisualShaderNodeScalarUniform::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeScalarUniform::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeScalarUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform float " + get_uniform_name();
-	if (hint == HINT_RANGE) {
-		code += " : hint_range(" + rtos(hint_range_min) + ", " + rtos(hint_range_max) + ")";
-	} else if (hint == HINT_RANGE_STEP) {
-		code += " : hint_range(" + rtos(hint_range_min) + ", " + rtos(hint_range_max) + ", " + rtos(hint_range_step) + ")";
-	}
-	if (default_value_enabled) {
-		code += " = " + rtos(default_value);
-	}
-	code += ";\n";
-	return code;
-}
-
-String VisualShaderNodeScalarUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-}
-
-void VisualShaderNodeScalarUniform::set_hint(Hint p_hint) {
-	ERR_FAIL_INDEX(int(p_hint), int(HINT_MAX));
-	if (hint == p_hint) {
-		return;
-	}
-	hint = p_hint;
-	emit_changed();
-}
-
-VisualShaderNodeScalarUniform::Hint VisualShaderNodeScalarUniform::get_hint() const {
-	return hint;
-}
-
-void VisualShaderNodeScalarUniform::set_min(float p_value) {
-	if (Math::is_equal_approx(hint_range_min, p_value)) {
-		return;
-	}
-	hint_range_min = p_value;
-	emit_changed();
-}
-
-float VisualShaderNodeScalarUniform::get_min() const {
-	return hint_range_min;
-}
-
-void VisualShaderNodeScalarUniform::set_max(float p_value) {
-	if (Math::is_equal_approx(hint_range_max, p_value)) {
-		return;
-	}
-	hint_range_max = p_value;
-	emit_changed();
-}
-
-float VisualShaderNodeScalarUniform::get_max() const {
-	return hint_range_max;
-}
-
-void VisualShaderNodeScalarUniform::set_step(float p_value) {
-	if (Math::is_equal_approx(hint_range_step, p_value)) {
-		return;
-	}
-	hint_range_step = p_value;
-	emit_changed();
-}
-
-float VisualShaderNodeScalarUniform::get_step() const {
-	return hint_range_step;
-}
-
-void VisualShaderNodeScalarUniform::set_default_value_enabled(bool p_default_value_enabled) {
-	if (default_value_enabled == p_default_value_enabled) {
-		return;
-	}
-	default_value_enabled = p_default_value_enabled;
-	emit_changed();
-}
-
-bool VisualShaderNodeScalarUniform::is_default_value_enabled() const {
-	return default_value_enabled;
-}
-
-void VisualShaderNodeScalarUniform::set_default_value(float p_default_value) {
-	if (Math::is_equal_approx(default_value, p_default_value)) {
-		return;
-	}
-	default_value = p_default_value;
-	emit_changed();
-}
-
-float VisualShaderNodeScalarUniform::get_default_value() const {
-	return default_value;
-}
-
-Vector<StringName> VisualShaderNodeScalarUniform::get_editable_properties() const {
-	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
-	props.push_back("hint");
-	if (hint == HINT_RANGE || hint == HINT_RANGE_STEP) {
-		props.push_back("min");
-		props.push_back("max");
-	}
-	if (hint == HINT_RANGE_STEP) {
-		props.push_back("step");
-	}
-	props.push_back("default_value_enabled");
-	if (default_value_enabled) {
-		props.push_back("default_value");
-	}
-	return props;
-}
-
-void VisualShaderNodeScalarUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_hint", "hint"), &VisualShaderNodeScalarUniform::set_hint);
-	ClassDB::bind_method(D_METHOD("get_hint"), &VisualShaderNodeScalarUniform::get_hint);
-
-	ClassDB::bind_method(D_METHOD("set_min", "value"), &VisualShaderNodeScalarUniform::set_min);
-	ClassDB::bind_method(D_METHOD("get_min"), &VisualShaderNodeScalarUniform::get_min);
-
-	ClassDB::bind_method(D_METHOD("set_max", "value"), &VisualShaderNodeScalarUniform::set_max);
-	ClassDB::bind_method(D_METHOD("get_max"), &VisualShaderNodeScalarUniform::get_max);
-
-	ClassDB::bind_method(D_METHOD("set_step", "value"), &VisualShaderNodeScalarUniform::set_step);
-	ClassDB::bind_method(D_METHOD("get_step"), &VisualShaderNodeScalarUniform::get_step);
-
-	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeScalarUniform::set_default_value_enabled);
-	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeScalarUniform::is_default_value_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeScalarUniform::set_default_value);
-	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeScalarUniform::get_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "hint", PROPERTY_HINT_ENUM, "None,Range,Range+Step"), "set_hint", "get_hint");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "min"), "set_min", "get_min");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max"), "set_max", "get_max");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "step"), "set_step", "get_step");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "default_value"), "set_default_value", "get_default_value");
-
-	BIND_ENUM_CONSTANT(HINT_NONE);
-	BIND_ENUM_CONSTANT(HINT_RANGE);
-	BIND_ENUM_CONSTANT(HINT_RANGE_STEP);
-	BIND_ENUM_CONSTANT(HINT_MAX);
-}
-
-VisualShaderNodeScalarUniform::VisualShaderNodeScalarUniform() {
-	hint = HINT_NONE;
-	hint_range_min = 0.0f;
-	hint_range_max = 1.0f;
-	hint_range_step = 0.1f;
-	default_value_enabled = false;
-	default_value = 0.0f;
-}
-
-////////////// Boolean Uniform
-
-String VisualShaderNodeBooleanUniform::get_caption() const {
-	return "BooleanUniform";
-}
-
-int VisualShaderNodeBooleanUniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeBooleanUniform::PortType VisualShaderNodeBooleanUniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeBooleanUniform::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeBooleanUniform::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeBooleanUniform::PortType VisualShaderNodeBooleanUniform::get_output_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeBooleanUniform::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeBooleanUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform bool " + get_uniform_name();
-	if (default_value_enabled) {
-		if (default_value) {
-			code += " = true";
-		} else {
-			code += " = false";
-		}
-	}
-	code += ";\n";
-	return code;
-}
-
-String VisualShaderNodeBooleanUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-}
-
-void VisualShaderNodeBooleanUniform::set_default_value_enabled(bool p_default_value_enabled) {
-	if (default_value_enabled == p_default_value_enabled) {
-		return;
-	}
-	default_value_enabled = p_default_value_enabled;
-	emit_changed();
-}
-
-bool VisualShaderNodeBooleanUniform::is_default_value_enabled() const {
-	return default_value_enabled;
-}
-
-void VisualShaderNodeBooleanUniform::set_default_value(bool p_default_value) {
-	if (default_value == p_default_value) {
-		return;
-	}
-	default_value = p_default_value;
-	emit_changed();
-}
-
-bool VisualShaderNodeBooleanUniform::get_default_value() const {
-	return default_value;
-}
-
-void VisualShaderNodeBooleanUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeBooleanUniform::set_default_value_enabled);
-	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeBooleanUniform::is_default_value_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeBooleanUniform::set_default_value);
-	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeBooleanUniform::get_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value"), "set_default_value", "get_default_value");
-}
-
-Vector<StringName> VisualShaderNodeBooleanUniform::get_editable_properties() const {
-	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
-	props.push_back("default_value_enabled");
-	if (default_value_enabled) {
-		props.push_back("default_value");
-	}
-	return props;
-}
-
-VisualShaderNodeBooleanUniform::VisualShaderNodeBooleanUniform() {
-	default_value_enabled = false;
-	default_value = false;
-}
-
-////////////// Color Uniform
-
-String VisualShaderNodeColorUniform::get_caption() const {
-	return "ColorUniform";
-}
-
-int VisualShaderNodeColorUniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeColorUniform::PortType VisualShaderNodeColorUniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeColorUniform::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeColorUniform::get_output_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeColorUniform::PortType VisualShaderNodeColorUniform::get_output_port_type(int p_port) const {
-	return p_port == 0 ? PORT_TYPE_VECTOR : PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeColorUniform::get_output_port_name(int p_port) const {
-	return p_port == 0 ? "color" : "alpha"; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeColorUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform vec4 " + get_uniform_name() + " : hint_color";
-	if (default_value_enabled) {
-		code += vformat(" = vec4(%.6f, %.6f, %.6f, %.6f)", default_value.r, default_value.g, default_value.b, default_value.a);
-	}
-	code += ";\n";
-	return code;
-}
-
-String VisualShaderNodeColorUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code = "\t" + p_output_vars[0] + " = " + get_uniform_name() + ".rgb;\n";
-	code += "\t" + p_output_vars[1] + " = " + get_uniform_name() + ".a;\n";
-	return code;
-}
-
-void VisualShaderNodeColorUniform::set_default_value_enabled(bool p_enabled) {
-	if (default_value_enabled == p_enabled) {
-		return;
-	}
-	default_value_enabled = p_enabled;
-	emit_changed();
-}
-
-bool VisualShaderNodeColorUniform::is_default_value_enabled() const {
-	return default_value_enabled;
-}
-
-void VisualShaderNodeColorUniform::set_default_value(const Color &p_value) {
-	if (default_value.is_equal_approx(p_value)) {
-		return;
-	}
-	default_value = p_value;
-	emit_changed();
-}
-
-Color VisualShaderNodeColorUniform::get_default_value() const {
-	return default_value;
-}
-
-void VisualShaderNodeColorUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeColorUniform::set_default_value_enabled);
-	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeColorUniform::is_default_value_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeColorUniform::set_default_value);
-	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeColorUniform::get_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "default_value"), "set_default_value", "get_default_value");
-}
-
-Vector<StringName> VisualShaderNodeColorUniform::get_editable_properties() const {
-	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
-	props.push_back("default_value_enabled");
-	if (default_value_enabled) {
-		props.push_back("default_value");
-	}
-	return props;
-}
-
-VisualShaderNodeColorUniform::VisualShaderNodeColorUniform() {
-	default_value_enabled = false;
-	default_value = Color(1.0, 1.0, 1.0, 1.0);
-}
-
-////////////// Vector Uniform
-
-String VisualShaderNodeVec3Uniform::get_caption() const {
-	return "VectorUniform";
-}
-
-int VisualShaderNodeVec3Uniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeVec3Uniform::PortType VisualShaderNodeVec3Uniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVec3Uniform::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeVec3Uniform::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeVec3Uniform::PortType VisualShaderNodeVec3Uniform::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeVec3Uniform::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeVec3Uniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform vec3 " + get_uniform_name();
-	if (default_value_enabled) {
-		code += vformat(" = vec3(%.6f, %.6f, %.6f)", default_value.x, default_value.y, default_value.z);
-	}
-	code += ";\n";
-	return code;
-}
-
-String VisualShaderNodeVec3Uniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-}
-
-void VisualShaderNodeVec3Uniform::set_default_value_enabled(bool p_enabled) {
-	default_value_enabled = p_enabled;
-	emit_changed();
-}
-
-bool VisualShaderNodeVec3Uniform::is_default_value_enabled() const {
-	return default_value_enabled;
-}
-
-void VisualShaderNodeVec3Uniform::set_default_value(const Vector3 &p_value) {
-	default_value = p_value;
-	emit_changed();
-}
-
-Vector3 VisualShaderNodeVec3Uniform::get_default_value() const {
-	return default_value;
-}
-
-void VisualShaderNodeVec3Uniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeVec3Uniform::set_default_value_enabled);
-	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeVec3Uniform::is_default_value_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeVec3Uniform::set_default_value);
-	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeVec3Uniform::get_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "default_value"), "set_default_value", "get_default_value");
-}
-
-Vector<StringName> VisualShaderNodeVec3Uniform::get_editable_properties() const {
-	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
-	props.push_back("default_value_enabled");
-	if (default_value_enabled) {
-		props.push_back("default_value");
-	}
-	return props;
-}
-
-VisualShaderNodeVec3Uniform::VisualShaderNodeVec3Uniform() {
-	default_value_enabled = false;
-}
-
-////////////// Transform Uniform
-
-String VisualShaderNodeTransformUniform::get_caption() const {
-	return "TransformUniform";
-}
-
-int VisualShaderNodeTransformUniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeTransformUniform::PortType VisualShaderNodeTransformUniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeTransformUniform::get_input_port_name(int p_port) const {
-	return String();
-}
-
-int VisualShaderNodeTransformUniform::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeTransformUniform::PortType VisualShaderNodeTransformUniform::get_output_port_type(int p_port) const {
-	return PORT_TYPE_TRANSFORM;
-}
-
-String VisualShaderNodeTransformUniform::get_output_port_name(int p_port) const {
-	return ""; //no output port means the editor will be used as port
-}
-
-String VisualShaderNodeTransformUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform mat4 " + get_uniform_name();
-	if (default_value_enabled) {
-		Vector3 row0 = default_value.basis.get_row(0);
-		Vector3 row1 = default_value.basis.get_row(1);
-		Vector3 row2 = default_value.basis.get_row(2);
-		Vector3 origin = default_value.origin;
-		code += " = mat4(" + vformat("vec4(%.6f, %.6f, %.6f, 0.0)", row0.x, row0.y, row0.z) + vformat(", vec4(%.6f, %.6f, %.6f, 0.0)", row1.x, row1.y, row1.z) + vformat(", vec4(%.6f, %.6f, %.6f, 0.0)", row2.x, row2.y, row2.z) + vformat(", vec4(%.6f, %.6f, %.6f, 1.0)", origin.x, origin.y, origin.z) + ")";
-	}
-	code += ";\n";
-	return code;
-}
-
-String VisualShaderNodeTransformUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
-}
-
-void VisualShaderNodeTransformUniform::set_default_value_enabled(bool p_enabled) {
-	default_value_enabled = p_enabled;
-	emit_changed();
-}
-
-bool VisualShaderNodeTransformUniform::is_default_value_enabled() const {
-	return default_value_enabled;
-}
-
-void VisualShaderNodeTransformUniform::set_default_value(const Transform &p_value) {
-	default_value = p_value;
-	emit_changed();
-}
-
-Transform VisualShaderNodeTransformUniform::get_default_value() const {
-	return default_value;
-}
-
-void VisualShaderNodeTransformUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeTransformUniform::set_default_value_enabled);
-	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeTransformUniform::is_default_value_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeTransformUniform::set_default_value);
-	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeTransformUniform::get_default_value);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "default_value"), "set_default_value", "get_default_value");
-}
-
-Vector<StringName> VisualShaderNodeTransformUniform::get_editable_properties() const {
-	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
-	props.push_back("default_value_enabled");
-	if (default_value_enabled) {
-		props.push_back("default_value");
-	}
-	return props;
-}
-
-VisualShaderNodeTransformUniform::VisualShaderNodeTransformUniform() {
-	default_value_enabled = false;
-	default_value = Transform(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
-}
-
-////////////// Texture Uniform
-
-String VisualShaderNodeTextureUniform::get_caption() const {
-	return "TextureUniform";
-}
-
-int VisualShaderNodeTextureUniform::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeTextureUniform::PortType VisualShaderNodeTextureUniform::get_input_port_type(int p_port) const {
-	return p_port == 0 ? PORT_TYPE_VECTOR : PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeTextureUniform::get_input_port_name(int p_port) const {
-	return p_port == 0 ? "uv" : "lod";
-}
-
-int VisualShaderNodeTextureUniform::get_output_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeTextureUniform::PortType VisualShaderNodeTextureUniform::get_output_port_type(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return PORT_TYPE_VECTOR;
-		case 1:
-			return PORT_TYPE_SCALAR;
-		case 2:
-			return PORT_TYPE_SAMPLER;
-		default:
-			return PORT_TYPE_SCALAR;
-	}
-}
-
-String VisualShaderNodeTextureUniform::get_output_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "rgb";
-		case 1:
-			return "alpha";
-		case 2:
-			return "sampler2D";
-		default:
-			return "";
-	}
-}
-
-bool VisualShaderNodeTextureUniform::is_code_generated() const {
-	return is_output_port_connected(0) || is_output_port_connected(1); // rgb or alpha
-}
-
-bool VisualShaderNodeTextureUniform::is_show_prop_names() const {
-	return false;
-}
-
-String VisualShaderNodeTextureUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform sampler2D " + get_uniform_name();
-
-	switch (texture_type) {
-		case TYPE_DATA:
-			if (color_default == COLOR_DEFAULT_BLACK) {
-				code += " : hint_black;\n";
-			} else {
-				code += ";\n";
-			}
-			break;
-		case TYPE_COLOR:
-			if (color_default == COLOR_DEFAULT_BLACK) {
-				code += " : hint_black_albedo;\n";
-			} else {
-				code += " : hint_albedo;\n";
-			}
-			break;
-		case TYPE_NORMALMAP:
-			code += " : hint_normal;\n";
-			break;
-		case TYPE_ANISO:
-			code += " : hint_aniso;\n";
-			break;
-	}
-
-	return code;
-}
-
-String VisualShaderNodeTextureUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String id = get_uniform_name();
-	String code = "\t{\n";
-	if (p_input_vars[0] == String()) { // Use UV by default.
-		if (p_input_vars[1] == String()) {
-			code += "\t\tvec4 n_tex_read = texture(" + id + ", UV.xy);\n";
-		} else {
-			code += "\t\tvec4 n_tex_read = textureLod(" + id + ", UV.xy, " + p_input_vars[1] + ");\n";
-		}
-	} else if (p_input_vars[1] == String()) {
-		//no lod
-		code += "\t\tvec4 n_tex_read = texture(" + id + ", " + p_input_vars[0] + ".xy);\n";
-	} else {
-		code += "\t\tvec4 n_tex_read = textureLod(" + id + ", " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ");\n";
-	}
-
-	code += "\t\t" + p_output_vars[0] + " = n_tex_read.rgb;\n";
-	code += "\t\t" + p_output_vars[1] + " = n_tex_read.a;\n";
-	code += "\t}\n";
-	return code;
-}
-
-void VisualShaderNodeTextureUniform::set_texture_type(TextureType p_type) {
-	texture_type = p_type;
-	emit_changed();
-}
-
-VisualShaderNodeTextureUniform::TextureType VisualShaderNodeTextureUniform::get_texture_type() const {
-	return texture_type;
-}
-
-void VisualShaderNodeTextureUniform::set_color_default(ColorDefault p_default) {
-	color_default = p_default;
-	emit_changed();
-}
-
-VisualShaderNodeTextureUniform::ColorDefault VisualShaderNodeTextureUniform::get_color_default() const {
-	return color_default;
-}
-
-Vector<StringName> VisualShaderNodeTextureUniform::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("texture_type");
-	props.push_back("color_default");
-	return props;
-}
-
-void VisualShaderNodeTextureUniform::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_texture_type", "type"), &VisualShaderNodeTextureUniform::set_texture_type);
-	ClassDB::bind_method(D_METHOD("get_texture_type"), &VisualShaderNodeTextureUniform::get_texture_type);
-
-	ClassDB::bind_method(D_METHOD("set_color_default", "type"), &VisualShaderNodeTextureUniform::set_color_default);
-	ClassDB::bind_method(D_METHOD("get_color_default"), &VisualShaderNodeTextureUniform::get_color_default);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_type", PROPERTY_HINT_ENUM, "Data,Color,Normalmap,Aniso"), "set_texture_type", "get_texture_type");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "color_default", PROPERTY_HINT_ENUM, "White Default,Black Default"), "set_color_default", "get_color_default");
-
-	BIND_ENUM_CONSTANT(TYPE_DATA);
-	BIND_ENUM_CONSTANT(TYPE_COLOR);
-	BIND_ENUM_CONSTANT(TYPE_NORMALMAP);
-	BIND_ENUM_CONSTANT(TYPE_ANISO);
-
-	BIND_ENUM_CONSTANT(COLOR_DEFAULT_WHITE);
-	BIND_ENUM_CONSTANT(COLOR_DEFAULT_BLACK);
-}
-
-String VisualShaderNodeTextureUniform::get_input_port_default_hint(int p_port) const {
-	if (p_port == 0) {
-		return "UV.xy";
-	}
-	return "";
-}
-
-VisualShaderNodeTextureUniform::VisualShaderNodeTextureUniform() {
-	texture_type = TYPE_DATA;
-	color_default = COLOR_DEFAULT_WHITE;
-	simple_decl = false;
-}
-
-////////////// Texture Uniform (Triplanar)
-
-String VisualShaderNodeTextureUniformTriplanar::get_caption() const {
-	return "TextureUniformTriplanar";
-}
-
-int VisualShaderNodeTextureUniformTriplanar::get_input_port_count() const {
-	return 2;
-}
-
-VisualShaderNodeTextureUniform::PortType VisualShaderNodeTextureUniformTriplanar::get_input_port_type(int p_port) const {
-	if (p_port == 0) {
-		return PORT_TYPE_VECTOR;
-	} else if (p_port == 1) {
-		return PORT_TYPE_VECTOR;
-	}
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeTextureUniformTriplanar::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "weights";
-	} else if (p_port == 1) {
-		return "pos";
-	}
-	return "";
-}
-
-String VisualShaderNodeTextureUniformTriplanar::generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code;
-
-	code += "// TRIPLANAR FUNCTION GLOBAL CODE\n";
-	code += "\tvec4 triplanar_texture(sampler2D p_sampler, vec3 p_weights, vec3 p_triplanar_pos) {\n";
-	code += "\t\tvec4 samp = vec4(0.0);\n";
-	code += "\t\tsamp += texture(p_sampler, p_triplanar_pos.xy) * p_weights.z;\n";
-	code += "\t\tsamp += texture(p_sampler, p_triplanar_pos.xz) * p_weights.y;\n";
-	code += "\t\tsamp += texture(p_sampler, p_triplanar_pos.zy * vec2(-1.0, 1.0)) * p_weights.x;\n";
-	code += "\t\treturn samp;\n";
-	code += "\t}\n";
-	code += "\n";
-	code += "\tuniform vec3 triplanar_scale = vec3(1.0, 1.0, 1.0);\n";
-	code += "\tuniform vec3 triplanar_offset;\n";
-	code += "\tuniform float triplanar_sharpness = 0.5;\n";
-	code += "\n";
-	code += "\tvarying vec3 triplanar_power_normal;\n";
-	code += "\tvarying vec3 triplanar_pos;\n";
-
-	return code;
-}
-
-String VisualShaderNodeTextureUniformTriplanar::generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code;
-
-	if (p_type == VisualShader::TYPE_VERTEX) {
-		code += "\t// TRIPLANAR FUNCTION VERTEX CODE\n";
-		code += "\t\ttriplanar_power_normal = pow(abs(NORMAL), vec3(triplanar_sharpness));\n";
-		code += "\t\ttriplanar_power_normal /= dot(triplanar_power_normal, vec3(1.0));\n";
-		code += "\t\ttriplanar_pos = VERTEX * triplanar_scale + triplanar_offset;\n";
-		code += "\t\ttriplanar_pos *= vec3(1.0, -1.0, 1.0);\n";
-	}
-
-	return code;
-}
-
-String VisualShaderNodeTextureUniformTriplanar::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String id = get_uniform_name();
-	String code = "\t{\n";
-
-	if (p_input_vars[0] == String() && p_input_vars[1] == String()) {
-		code += "\t\tvec4 n_tex_read = triplanar_texture( " + id + ", triplanar_power_normal, triplanar_pos );\n";
-	} else if (p_input_vars[0] != String() && p_input_vars[1] == String()) {
-		code += "\t\tvec4 n_tex_read = triplanar_texture( " + id + ", " + p_input_vars[0] + ", triplanar_pos );\n";
-	} else if (p_input_vars[0] == String() && p_input_vars[1] != String()) {
-		code += "\t\tvec4 n_tex_read = triplanar_texture( " + id + ", triplanar_power_normal," + p_input_vars[1] + " );\n";
-	} else {
-		code += "\t\tvec4 n_tex_read = triplanar_texture( " + id + ", " + p_input_vars[0] + ", " + p_input_vars[1] + " );\n";
-	}
-
-	code += "\t\t" + p_output_vars[0] + " = n_tex_read.rgb;\n";
-	code += "\t\t" + p_output_vars[1] + " = n_tex_read.a;\n";
-	code += "\t}\n";
-
-	return code;
-}
-
-String VisualShaderNodeTextureUniformTriplanar::get_input_port_default_hint(int p_port) const {
-	if (p_port == 0) {
-		return "default";
-	} else if (p_port == 1) {
-		return "default";
-	}
-	return "";
-}
-
-VisualShaderNodeTextureUniformTriplanar::VisualShaderNodeTextureUniformTriplanar() {
-}
-
-////////////// CubeMap Uniform
-
-String VisualShaderNodeCubeMapUniform::get_caption() const {
-	return "CubeMapUniform";
-}
-
-int VisualShaderNodeCubeMapUniform::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeCubeMapUniform::PortType VisualShaderNodeCubeMapUniform::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SAMPLER;
-}
-
-String VisualShaderNodeCubeMapUniform::get_output_port_name(int p_port) const {
-	return "samplerCube";
-}
-
-int VisualShaderNodeCubeMapUniform::get_input_port_count() const {
-	return 0;
-}
-
-VisualShaderNodeCubeMapUniform::PortType VisualShaderNodeCubeMapUniform::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeCubeMapUniform::get_input_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeCubeMapUniform::get_input_port_default_hint(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeCubeMapUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
-	String code = "uniform samplerCube " + get_uniform_name();
-
-	switch (texture_type) {
-		case TYPE_DATA:
-			if (color_default == COLOR_DEFAULT_BLACK) {
-				code += " : hint_black;\n";
-			} else {
-				code += ";\n";
-			}
-			break;
-		case TYPE_COLOR:
-			if (color_default == COLOR_DEFAULT_BLACK) {
-				code += " : hint_black_albedo;\n";
-			} else {
-				code += " : hint_albedo;\n";
-			}
-			break;
-		case TYPE_NORMALMAP:
-			code += " : hint_normal;\n";
-			break;
-		case TYPE_ANISO:
-			code += " : hint_aniso;\n";
-			break;
-	}
-
-	return code;
-}
-
-String VisualShaderNodeCubeMapUniform::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	return String();
-}
-
-VisualShaderNodeCubeMapUniform::VisualShaderNodeCubeMapUniform() {
-}
-
-////////////// If
-
-String VisualShaderNodeIf::get_caption() const {
-	return "If";
-}
-
-int VisualShaderNodeIf::get_input_port_count() const {
-	return 6;
-}
-
-VisualShaderNodeIf::PortType VisualShaderNodeIf::get_input_port_type(int p_port) const {
-	if (p_port == 0 || p_port == 1 || p_port == 2) {
-		return PORT_TYPE_SCALAR;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeIf::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "a";
-		case 1:
-			return "b";
-		case 2:
-			return "tolerance";
-		case 3:
-			return "a == b";
-		case 4:
-			return "a > b";
-		case 5:
-			return "a < b";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeIf::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeIf::PortType VisualShaderNodeIf::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeIf::get_output_port_name(int p_port) const {
-	return "result";
-}
-
-String VisualShaderNodeIf::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	code += "\tif(abs(" + p_input_vars[0] + " - " + p_input_vars[1] + ") < " + p_input_vars[2] + ")\n"; // abs(a - b) < tolerance eg. a == b
-	code += "\t{\n";
-	code += "\t\t" + p_output_vars[0] + " = " + p_input_vars[3] + ";\n";
-	code += "\t}\n";
-	code += "\telse if(" + p_input_vars[0] + " < " + p_input_vars[1] + ")\n"; // a < b
-	code += "\t{\n";
-	code += "\t\t" + p_output_vars[0] + " = " + p_input_vars[5] + ";\n";
-	code += "\t}\n";
-	code += "\telse\n"; // a > b (or a >= b if abs(a - b) < tolerance is false)
-	code += "\t{\n";
-	code += "\t\t" + p_output_vars[0] + " = " + p_input_vars[4] + ";\n";
-	code += "\t}\n";
-	return code;
-}
-
-VisualShaderNodeIf::VisualShaderNodeIf() {
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, CMP_EPSILON);
-	set_input_port_default_value(3, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(4, Vector3(0.0, 0.0, 0.0));
-	set_input_port_default_value(5, Vector3(0.0, 0.0, 0.0));
-	simple_decl = false;
-}
-
-////////////// Switch
-
-String VisualShaderNodeSwitch::get_caption() const {
-	return "VectorSwitch";
-}
-
-int VisualShaderNodeSwitch::get_input_port_count() const {
-	return 3;
-}
-
-VisualShaderNodeSwitch::PortType VisualShaderNodeSwitch::get_input_port_type(int p_port) const {
-	if (p_port == 0) {
-		return PORT_TYPE_BOOLEAN;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeSwitch::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "value";
-		case 1:
-			return "true";
-		case 2:
-			return "false";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeSwitch::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeSwitch::PortType VisualShaderNodeSwitch::get_output_port_type(int p_port) const {
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeSwitch::get_output_port_name(int p_port) const {
-	return "result";
-}
-
-String VisualShaderNodeSwitch::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String code;
-	code += "\tif(" + p_input_vars[0] + ")\n";
-	code += "\t{\n";
-	code += "\t\t" + p_output_vars[0] + " = " + p_input_vars[1] + ";\n";
-	code += "\t}\n";
-	code += "\telse\n";
-	code += "\t{\n";
-	code += "\t\t" + p_output_vars[0] + " = " + p_input_vars[2] + ";\n";
-	code += "\t}\n";
-	return code;
-}
-
-VisualShaderNodeSwitch::VisualShaderNodeSwitch() {
-	set_input_port_default_value(0, false);
-	set_input_port_default_value(1, Vector3(1.0, 1.0, 1.0));
-	set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0));
-	simple_decl = false;
-}
-
-////////////// Switch(scalar)
-
-String VisualShaderNodeScalarSwitch::get_caption() const {
-	return "ScalarSwitch";
-}
-
-VisualShaderNodeScalarSwitch::PortType VisualShaderNodeScalarSwitch::get_input_port_type(int p_port) const {
-	if (p_port == 0) {
-		return PORT_TYPE_BOOLEAN;
-	}
-	return PORT_TYPE_SCALAR;
-}
-
-VisualShaderNodeScalarSwitch::PortType VisualShaderNodeScalarSwitch::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-VisualShaderNodeScalarSwitch::VisualShaderNodeScalarSwitch() {
-	set_input_port_default_value(0, false);
-	set_input_port_default_value(1, 1.0);
-	set_input_port_default_value(2, 0.0);
-}
-
-////////////// Fresnel
-
-String VisualShaderNodeFresnel::get_caption() const {
-	return "Fresnel";
-}
-
-int VisualShaderNodeFresnel::get_input_port_count() const {
-	return 4;
-}
-
-VisualShaderNodeFresnel::PortType VisualShaderNodeFresnel::get_input_port_type(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return PORT_TYPE_VECTOR;
-		case 1:
-			return PORT_TYPE_VECTOR;
-		case 2:
-			return PORT_TYPE_BOOLEAN;
-		case 3:
-			return PORT_TYPE_SCALAR;
-		default:
-			return PORT_TYPE_VECTOR;
-	}
-}
-
-String VisualShaderNodeFresnel::get_input_port_name(int p_port) const {
-	switch (p_port) {
-		case 0:
-			return "normal";
-		case 1:
-			return "view";
-		case 2:
-			return "invert";
-		case 3:
-			return "power";
-		default:
-			return "";
-	}
-}
-
-int VisualShaderNodeFresnel::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeFresnel::PortType VisualShaderNodeFresnel::get_output_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeFresnel::get_output_port_name(int p_port) const {
-	return "result";
-}
-
-bool VisualShaderNodeFresnel::is_generate_input_var(int p_port) const {
-	if (p_port == 2) {
-		return false;
-	}
-	return true;
-}
-
-String VisualShaderNodeFresnel::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	String normal;
-	String view;
-	if (p_input_vars[0] == String()) {
-		normal = "NORMAL";
-	} else {
-		normal = p_input_vars[0];
-	}
-	if (p_input_vars[1] == String()) {
-		view = "VIEW";
-	} else {
-		view = p_input_vars[1];
-	}
-
-	if (is_input_port_connected(2)) {
-		return "\t" + p_output_vars[0] + " = " + p_input_vars[2] + " ? (pow(clamp(dot(" + normal + ", " + view + "), 0.0, 1.0), " + p_input_vars[3] + ")) : (pow(1.0 - clamp(dot(" + normal + ", " + view + "), 0.0, 1.0), " + p_input_vars[3] + "));\n";
-	} else {
-		if (get_input_port_default_value(2)) {
-			return "\t" + p_output_vars[0] + " = pow(clamp(dot(" + normal + ", " + view + "), 0.0, 1.0), " + p_input_vars[3] + ");\n";
-		} else {
-			return "\t" + p_output_vars[0] + " = pow(1.0 - clamp(dot(" + normal + ", " + view + "), 0.0, 1.0), " + p_input_vars[3] + ");\n";
-		}
-	}
-}
-
-String VisualShaderNodeFresnel::get_input_port_default_hint(int p_port) const {
-	if (p_port == 0) {
-		return "default";
-	} else if (p_port == 1) {
-		return "default";
-	}
-	return "";
-}
-
-VisualShaderNodeFresnel::VisualShaderNodeFresnel() {
-	set_input_port_default_value(2, false);
-	set_input_port_default_value(3, 1.0);
-}
-
-////////////// Is
-
-String VisualShaderNodeIs::get_caption() const {
-	return "Is";
-}
-
-int VisualShaderNodeIs::get_input_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeIs::PortType VisualShaderNodeIs::get_input_port_type(int p_port) const {
-	return PORT_TYPE_SCALAR;
-}
-
-String VisualShaderNodeIs::get_input_port_name(int p_port) const {
-	return "";
-}
-
-int VisualShaderNodeIs::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeIs::PortType VisualShaderNodeIs::get_output_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeIs::get_output_port_name(int p_port) const {
-	return "";
-}
-
-String VisualShaderNodeIs::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *funcs[FUNC_IS_NAN + 1] = {
-		"isinf($)",
-		"isnan($)"
-	};
-
-	String code;
-	code += "\t" + p_output_vars[0] + " = " + String(funcs[func]).replace("$", p_input_vars[0]) + ";\n";
-	return code;
-}
-
-void VisualShaderNodeIs::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeIs::Function VisualShaderNodeIs::get_function() const {
-	return func;
-}
-
-Vector<StringName> VisualShaderNodeIs::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("function");
-	return props;
-}
-
-void VisualShaderNodeIs::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeIs::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeIs::get_function);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Inf,NaN"), "set_function", "get_function");
-
-	BIND_ENUM_CONSTANT(FUNC_IS_INF);
-	BIND_ENUM_CONSTANT(FUNC_IS_NAN);
-}
-
-VisualShaderNodeIs::VisualShaderNodeIs() {
-	func = FUNC_IS_INF;
-	set_input_port_default_value(0, 0.0);
-}
-
-////////////// Compare
-
-String VisualShaderNodeCompare::get_caption() const {
-	return "Compare";
-}
-
-int VisualShaderNodeCompare::get_input_port_count() const {
-	if (ctype == CTYPE_SCALAR && (func == FUNC_EQUAL || func == FUNC_NOT_EQUAL)) {
-		return 3;
-	}
-	return 2;
-}
-
-VisualShaderNodeCompare::PortType VisualShaderNodeCompare::get_input_port_type(int p_port) const {
-	if (p_port == 2) {
-		return PORT_TYPE_SCALAR;
-	}
-	switch (ctype) {
-		case CTYPE_SCALAR:
-			return PORT_TYPE_SCALAR;
-		case CTYPE_VECTOR:
-			return PORT_TYPE_VECTOR;
-		case CTYPE_BOOLEAN:
-			return PORT_TYPE_BOOLEAN;
-		case CTYPE_TRANSFORM:
-			return PORT_TYPE_TRANSFORM;
-	}
-	return PORT_TYPE_VECTOR;
-}
-
-String VisualShaderNodeCompare::get_input_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "a";
-	} else if (p_port == 1) {
-		return "b";
-	} else if (p_port == 2) {
-		return "tolerance";
-	}
-	return "";
-}
-
-int VisualShaderNodeCompare::get_output_port_count() const {
-	return 1;
-}
-
-VisualShaderNodeCompare::PortType VisualShaderNodeCompare::get_output_port_type(int p_port) const {
-	return PORT_TYPE_BOOLEAN;
-}
-
-String VisualShaderNodeCompare::get_output_port_name(int p_port) const {
-	if (p_port == 0) {
-		return "result";
-	}
-	return "";
-}
-
-String VisualShaderNodeCompare::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
-	if (ctype == CTYPE_BOOLEAN || ctype == CTYPE_TRANSFORM) {
-		if (func > FUNC_NOT_EQUAL) {
-			return TTR("Invalid comparison function for that type.");
-		}
-	}
-
-	return "";
-}
-
-String VisualShaderNodeCompare::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
-	static const char *ops[FUNC_LESS_THAN_EQUAL + 1] = {
-		"==",
-		"!=",
-		">",
-		">=",
-		"<",
-		"<=",
-	};
-
-	static const char *funcs[FUNC_LESS_THAN_EQUAL + 1] = {
-		"equal($)",
-		"notEqual($)",
-		"greaterThan($)",
-		"greaterThanEqual($)",
-		"lessThan($)",
-		"lessThanEqual($)",
-	};
-
-	static const char *conds[COND_ANY + 1] = {
-		"all($)",
-		"any($)",
-	};
-
-	String code;
-	switch (ctype) {
-		case CTYPE_SCALAR:
-			if (func == FUNC_EQUAL) {
-				code += "\t" + p_output_vars[0] + " = (abs(" + p_input_vars[0] + " - " + p_input_vars[1] + ") < " + p_input_vars[2] + ");";
-			} else if (func == FUNC_NOT_EQUAL) {
-				code += "\t" + p_output_vars[0] + " = !(abs(" + p_input_vars[0] + " - " + p_input_vars[1] + ") < " + p_input_vars[2] + ");";
-			} else {
-				code += "\t" + p_output_vars[0] + " = " + (p_input_vars[0] + "$" + p_input_vars[1]).replace("$", ops[func]) + ";\n";
-			}
-			break;
-
-		case CTYPE_VECTOR:
-			code += "\t{\n";
-			code += "\t\tbvec3 _bv = " + String(funcs[func]).replace("$", p_input_vars[0] + ", " + p_input_vars[1]) + ";\n";
-			code += "\t\t" + p_output_vars[0] + " = " + String(conds[condition]).replace("$", "_bv") + ";\n";
-			code += "\t}\n";
-			break;
-
-		case CTYPE_BOOLEAN:
-			if (func > FUNC_NOT_EQUAL) {
-				return "\t" + p_output_vars[0] + " = false;\n";
-			}
-			code += "\t" + p_output_vars[0] + " = " + (p_input_vars[0] + " $ " + p_input_vars[1]).replace("$", ops[func]) + ";\n";
-			break;
-
-		case CTYPE_TRANSFORM:
-			if (func > FUNC_NOT_EQUAL) {
-				return "\t" + p_output_vars[0] + " = false;\n";
-			}
-			code += "\t" + p_output_vars[0] + " = " + (p_input_vars[0] + " $ " + p_input_vars[1]).replace("$", ops[func]) + ";\n";
-			break;
-
-		default:
-			break;
-	}
-	return code;
-}
-
-void VisualShaderNodeCompare::set_comparison_type(ComparisonType p_type) {
-	ctype = p_type;
-
-	switch (ctype) {
-		case CTYPE_SCALAR:
-			set_input_port_default_value(0, 0.0);
-			set_input_port_default_value(1, 0.0);
-			simple_decl = true;
-			break;
-		case CTYPE_VECTOR:
-			set_input_port_default_value(0, Vector3(0.0, 0.0, 0.0));
-			set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0));
-			simple_decl = false;
-			break;
-		case CTYPE_BOOLEAN:
-			set_input_port_default_value(0, false);
-			set_input_port_default_value(1, false);
-			simple_decl = true;
-			break;
-		case CTYPE_TRANSFORM:
-			set_input_port_default_value(0, Transform());
-			set_input_port_default_value(1, Transform());
-			simple_decl = true;
-			break;
-	}
-	emit_changed();
-}
-
-VisualShaderNodeCompare::ComparisonType VisualShaderNodeCompare::get_comparison_type() const {
-	return ctype;
-}
-
-void VisualShaderNodeCompare::set_function(Function p_func) {
-	func = p_func;
-	emit_changed();
-}
-
-VisualShaderNodeCompare::Function VisualShaderNodeCompare::get_function() const {
-	return func;
-}
-
-void VisualShaderNodeCompare::set_condition(Condition p_cond) {
-	condition = p_cond;
-	emit_changed();
-}
-
-VisualShaderNodeCompare::Condition VisualShaderNodeCompare::get_condition() const {
-	return condition;
-}
-
-Vector<StringName> VisualShaderNodeCompare::get_editable_properties() const {
-	Vector<StringName> props;
-	props.push_back("type");
-	props.push_back("function");
-	if (ctype == CTYPE_VECTOR) {
-		props.push_back("condition");
-	}
-	return props;
-}
-
-void VisualShaderNodeCompare::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_comparison_type", "type"), &VisualShaderNodeCompare::set_comparison_type);
-	ClassDB::bind_method(D_METHOD("get_comparison_type"), &VisualShaderNodeCompare::get_comparison_type);
-
-	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeCompare::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeCompare::get_function);
-
-	ClassDB::bind_method(D_METHOD("set_condition", "condition"), &VisualShaderNodeCompare::set_condition);
-	ClassDB::bind_method(D_METHOD("get_condition"), &VisualShaderNodeCompare::get_condition);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, "Scalar,Vector,Boolean,Transform"), "set_comparison_type", "get_comparison_type");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "a == b,a != b,a > b,a >= b,a < b,a <= b"), "set_function", "get_function");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "condition", PROPERTY_HINT_ENUM, "All,Any"), "set_condition", "get_condition");
-
-	BIND_ENUM_CONSTANT(CTYPE_SCALAR);
-	BIND_ENUM_CONSTANT(CTYPE_VECTOR);
-	BIND_ENUM_CONSTANT(CTYPE_BOOLEAN);
-	BIND_ENUM_CONSTANT(CTYPE_TRANSFORM);
-
-	BIND_ENUM_CONSTANT(FUNC_EQUAL);
-	BIND_ENUM_CONSTANT(FUNC_NOT_EQUAL);
-	BIND_ENUM_CONSTANT(FUNC_GREATER_THAN);
-	BIND_ENUM_CONSTANT(FUNC_GREATER_THAN_EQUAL);
-	BIND_ENUM_CONSTANT(FUNC_LESS_THAN);
-	BIND_ENUM_CONSTANT(FUNC_LESS_THAN_EQUAL);
-
-	BIND_ENUM_CONSTANT(COND_ALL);
-	BIND_ENUM_CONSTANT(COND_ANY);
-}
-
-VisualShaderNodeCompare::VisualShaderNodeCompare() {
-	ctype = CTYPE_SCALAR;
-	func = FUNC_EQUAL;
-	condition = COND_ALL;
-	set_input_port_default_value(0, 0.0);
-	set_input_port_default_value(1, 0.0);
-	set_input_port_default_value(2, CMP_EPSILON);
-}
diff --git a/scene/resources/visual_shader_nodes.h b/scene/resources/visual_shader_nodes.h
deleted file mode 100644
index 4eb5e2cfa..000000000
--- a/scene/resources/visual_shader_nodes.h
+++ /dev/null
@@ -1,1805 +0,0 @@
-/*************************************************************************/
-/*  visual_shader_nodes.h                                                */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef VISUAL_SHADER_NODES_H
-#define VISUAL_SHADER_NODES_H
-
-#include "scene/resources/visual_shader.h"
-
-///////////////////////////////////////
-/// CONSTANTS
-///////////////////////////////////////
-
-class VisualShaderNodeScalarConstant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarConstant, VisualShaderNode);
-	float constant;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_constant(float p_value);
-	float get_constant() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeScalarConstant();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeBooleanConstant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeBooleanConstant, VisualShaderNode);
-	bool constant;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_constant(bool p_value);
-	bool get_constant() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeBooleanConstant();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeColorConstant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeColorConstant, VisualShaderNode);
-	Color constant;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_constant(Color p_value);
-	Color get_constant() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeColorConstant();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVec3Constant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVec3Constant, VisualShaderNode);
-	Vector3 constant;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_constant(Vector3 p_value);
-	Vector3 get_constant() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeVec3Constant();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeTransformConstant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformConstant, VisualShaderNode);
-	Transform constant;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_constant(Transform p_value);
-	Transform get_constant() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeTransformConstant();
-};
-
-///////////////////////////////////////
-/// TEXTURES
-///////////////////////////////////////
-
-class VisualShaderNodeTexture : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTexture, VisualShaderNode);
-	Ref<Texture> texture;
-
-public:
-	enum Source {
-		SOURCE_TEXTURE,
-		SOURCE_SCREEN,
-		SOURCE_2D_TEXTURE,
-		SOURCE_2D_NORMAL,
-		SOURCE_DEPTH,
-		SOURCE_PORT,
-	};
-
-	enum TextureType {
-		TYPE_DATA,
-		TYPE_COLOR,
-		TYPE_NORMALMAP
-	};
-
-private:
-	Source source;
-	TextureType texture_type;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String get_input_port_default_hint(int p_port) const;
-
-	virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_source(Source p_source);
-	Source get_source() const;
-
-	void set_texture(Ref<Texture> p_value);
-	Ref<Texture> get_texture() const;
-
-	void set_texture_type(TextureType p_type);
-	TextureType get_texture_type() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
-
-	VisualShaderNodeTexture();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeTexture::TextureType)
-VARIANT_ENUM_CAST(VisualShaderNodeTexture::Source)
-
-///////////////////////////////////////
-
-class VisualShaderNodeCubeMap : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeCubeMap, VisualShaderNode);
-	Ref<CubeMap> cube_map;
-
-public:
-	enum Source {
-		SOURCE_TEXTURE,
-		SOURCE_PORT
-	};
-
-	enum TextureType {
-		TYPE_DATA,
-		TYPE_COLOR,
-		TYPE_NORMALMAP
-	};
-
-private:
-	Source source;
-	TextureType texture_type;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-	virtual String get_input_port_default_hint(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_source(Source p_source);
-	Source get_source() const;
-
-	void set_cube_map(Ref<CubeMap> p_value);
-	Ref<CubeMap> get_cube_map() const;
-
-	void set_texture_type(TextureType p_type);
-	TextureType get_texture_type() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-	virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
-
-	VisualShaderNodeCubeMap();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeCubeMap::TextureType)
-VARIANT_ENUM_CAST(VisualShaderNodeCubeMap::Source)
-
-///////////////////////////////////////
-/// OPS
-///////////////////////////////////////
-
-class VisualShaderNodeScalarOp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarOp, VisualShaderNode);
-
-public:
-	enum Operator {
-		OP_ADD,
-		OP_SUB,
-		OP_MUL,
-		OP_DIV,
-		OP_MOD,
-		OP_POW,
-		OP_MAX,
-		OP_MIN,
-		OP_ATAN2,
-		OP_STEP
-	};
-
-protected:
-	Operator op;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_operator(Operator p_op);
-	Operator get_operator() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeScalarOp();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeScalarOp::Operator)
-
-class VisualShaderNodeVectorOp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorOp, VisualShaderNode);
-
-public:
-	enum Operator {
-		OP_ADD,
-		OP_SUB,
-		OP_MUL,
-		OP_DIV,
-		OP_MOD,
-		OP_POW,
-		OP_MAX,
-		OP_MIN,
-		OP_CROSS,
-		OP_ATAN2,
-		OP_REFLECT,
-		OP_STEP
-	};
-
-protected:
-	Operator op;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_operator(Operator p_op);
-	Operator get_operator() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeVectorOp();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeVectorOp::Operator)
-
-///////////////////////////////////////
-
-class VisualShaderNodeColorOp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeColorOp, VisualShaderNode);
-
-public:
-	enum Operator {
-		OP_SCREEN,
-		OP_DIFFERENCE,
-		OP_DARKEN,
-		OP_LIGHTEN,
-		OP_OVERLAY,
-		OP_DODGE,
-		OP_BURN,
-		OP_SOFT_LIGHT,
-		OP_HARD_LIGHT
-	};
-
-protected:
-	Operator op;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_operator(Operator p_op);
-	Operator get_operator() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeColorOp();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeColorOp::Operator)
-
-///////////////////////////////////////
-/// TRANSFORM-TRANSFORM MULTIPLICATION
-///////////////////////////////////////
-
-class VisualShaderNodeTransformMult : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformMult, VisualShaderNode);
-
-public:
-	enum Operator {
-		OP_AxB,
-		OP_BxA,
-		OP_AxB_COMP,
-		OP_BxA_COMP
-	};
-
-protected:
-	Operator op;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_operator(Operator p_op);
-	Operator get_operator() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeTransformMult();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeTransformMult::Operator)
-
-///////////////////////////////////////
-/// TRANSFORM-VECTOR MULTIPLICATION
-///////////////////////////////////////
-
-class VisualShaderNodeTransformVecMult : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformVecMult, VisualShaderNode);
-
-public:
-	enum Operator {
-		OP_AxB,
-		OP_BxA,
-		OP_3x3_AxB,
-		OP_3x3_BxA,
-	};
-
-protected:
-	Operator op;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_operator(Operator p_op);
-	Operator get_operator() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeTransformVecMult();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeTransformVecMult::Operator)
-
-///////////////////////////////////////
-/// SCALAR FUNC
-///////////////////////////////////////
-
-class VisualShaderNodeScalarFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_SIN,
-		FUNC_COS,
-		FUNC_TAN,
-		FUNC_ASIN,
-		FUNC_ACOS,
-		FUNC_ATAN,
-		FUNC_SINH,
-		FUNC_COSH,
-		FUNC_TANH,
-		FUNC_LOG,
-		FUNC_EXP,
-		FUNC_SQRT,
-		FUNC_ABS,
-		FUNC_SIGN,
-		FUNC_FLOOR,
-		FUNC_ROUND,
-		FUNC_CEIL,
-		FUNC_FRAC,
-		FUNC_SATURATE,
-		FUNC_NEGATE,
-		FUNC_ACOSH,
-		FUNC_ASINH,
-		FUNC_ATANH,
-		FUNC_DEGREES,
-		FUNC_EXP2,
-		FUNC_INVERSE_SQRT,
-		FUNC_LOG2,
-		FUNC_RADIANS,
-		FUNC_RECIPROCAL,
-		FUNC_ROUNDEVEN,
-		FUNC_TRUNC,
-		FUNC_ONEMINUS
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeScalarFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeScalarFunc::Function)
-
-///////////////////////////////////////
-/// VECTOR FUNC
-///////////////////////////////////////
-
-class VisualShaderNodeVectorFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_NORMALIZE,
-		FUNC_SATURATE,
-		FUNC_NEGATE,
-		FUNC_RECIPROCAL,
-		FUNC_RGB2HSV,
-		FUNC_HSV2RGB,
-		FUNC_ABS,
-		FUNC_ACOS,
-		FUNC_ACOSH,
-		FUNC_ASIN,
-		FUNC_ASINH,
-		FUNC_ATAN,
-		FUNC_ATANH,
-		FUNC_CEIL,
-		FUNC_COS,
-		FUNC_COSH,
-		FUNC_DEGREES,
-		FUNC_EXP,
-		FUNC_EXP2,
-		FUNC_FLOOR,
-		FUNC_FRAC,
-		FUNC_INVERSE_SQRT,
-		FUNC_LOG,
-		FUNC_LOG2,
-		FUNC_RADIANS,
-		FUNC_ROUND,
-		FUNC_ROUNDEVEN,
-		FUNC_SIGN,
-		FUNC_SIN,
-		FUNC_SINH,
-		FUNC_SQRT,
-		FUNC_TAN,
-		FUNC_TANH,
-		FUNC_TRUNC,
-		FUNC_ONEMINUS
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeVectorFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeVectorFunc::Function)
-
-///////////////////////////////////////
-/// COLOR FUNC
-///////////////////////////////////////
-
-class VisualShaderNodeColorFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeColorFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_GRAYSCALE,
-		FUNC_SEPIA
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeColorFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeColorFunc::Function)
-
-///////////////////////////////////////
-/// TRANSFORM FUNC
-///////////////////////////////////////
-
-class VisualShaderNodeTransformFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_INVERSE,
-		FUNC_TRANSPOSE
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeTransformFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeTransformFunc::Function)
-
-///////////////////////////////////////
-/// DOT
-///////////////////////////////////////
-
-class VisualShaderNodeDotProduct : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeDotProduct, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeDotProduct();
-};
-
-///////////////////////////////////////
-/// LENGTH
-///////////////////////////////////////
-
-class VisualShaderNodeVectorLen : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorLen, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorLen();
-};
-
-///////////////////////////////////////
-/// DETERMINANT
-///////////////////////////////////////
-
-class VisualShaderNodeDeterminant : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeDeterminant, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeDeterminant();
-};
-
-///////////////////////////////////////
-/// CLAMP
-///////////////////////////////////////
-
-class VisualShaderNodeScalarClamp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarClamp, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeScalarClamp();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorClamp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorClamp, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorClamp();
-};
-
-///////////////////////////////////////
-/// DERIVATIVE FUNCTIONS
-///////////////////////////////////////
-
-class VisualShaderNodeScalarDerivativeFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarDerivativeFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_SUM,
-		FUNC_X,
-		FUNC_Y
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeScalarDerivativeFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeScalarDerivativeFunc::Function)
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorDerivativeFunc : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorDerivativeFunc, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_SUM,
-		FUNC_X,
-		FUNC_Y
-	};
-
-protected:
-	Function func;
-
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeVectorDerivativeFunc();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeVectorDerivativeFunc::Function)
-
-///////////////////////////////////////
-/// FACEFORWARD
-///////////////////////////////////////
-
-class VisualShaderNodeFaceForward : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeFaceForward, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeFaceForward();
-};
-
-///////////////////////////////////////
-/// OUTER PRODUCT
-///////////////////////////////////////
-
-class VisualShaderNodeOuterProduct : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeOuterProduct, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeOuterProduct();
-};
-
-///////////////////////////////////////
-/// STEP
-///////////////////////////////////////
-
-class VisualShaderNodeVectorScalarStep : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorScalarStep, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorScalarStep();
-};
-
-///////////////////////////////////////
-/// SMOOTHSTEP
-///////////////////////////////////////
-
-class VisualShaderNodeScalarSmoothStep : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarSmoothStep, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeScalarSmoothStep();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorSmoothStep : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorSmoothStep, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorSmoothStep();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorScalarSmoothStep : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorScalarSmoothStep, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorScalarSmoothStep();
-};
-
-///////////////////////////////////////
-/// DISTANCE
-///////////////////////////////////////
-
-class VisualShaderNodeVectorDistance : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorDistance, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorDistance();
-};
-
-///////////////////////////////////////
-/// REFRACT
-///////////////////////////////////////
-
-class VisualShaderNodeVectorRefract : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorRefract, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorRefract();
-};
-
-///////////////////////////////////////
-/// MIX
-///////////////////////////////////////
-
-class VisualShaderNodeScalarInterp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeScalarInterp, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeScalarInterp();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorInterp : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorInterp, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorInterp();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVectorScalarMix : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorScalarMix, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorScalarMix();
-};
-
-///////////////////////////////////////
-/// COMPOSE
-///////////////////////////////////////
-
-class VisualShaderNodeVectorCompose : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorCompose, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorCompose();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeTransformCompose : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformCompose, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeTransformCompose();
-};
-
-///////////////////////////////////////
-/// DECOMPOSE
-///////////////////////////////////////
-
-class VisualShaderNodeVectorDecompose : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeVectorDecompose, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeVectorDecompose();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeTransformDecompose : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeTransformDecompose, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeTransformDecompose();
-};
-
-///////////////////////////////////////
-/// UNIFORMS
-///////////////////////////////////////
-
-class VisualShaderNodeScalarUniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeScalarUniform, VisualShaderNodeUniform);
-
-public:
-	enum Hint {
-		HINT_NONE,
-		HINT_RANGE,
-		HINT_RANGE_STEP,
-		HINT_MAX,
-	};
-
-private:
-	Hint hint = HINT_NONE;
-	float hint_range_min;
-	float hint_range_max;
-	float hint_range_step;
-	bool default_value_enabled;
-	float default_value;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_hint(Hint p_hint);
-	Hint get_hint() const;
-
-	void set_min(float p_value);
-	float get_min() const;
-
-	void set_max(float p_value);
-	float get_max() const;
-
-	void set_step(float p_value);
-	float get_step() const;
-
-	void set_default_value_enabled(bool p_enabled);
-	bool is_default_value_enabled() const;
-
-	void set_default_value(float p_value);
-	float get_default_value() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeScalarUniform();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeScalarUniform::Hint)
-
-///////////////////////////////////////
-
-class VisualShaderNodeBooleanUniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeBooleanUniform, VisualShaderNodeUniform);
-
-private:
-	bool default_value_enabled;
-	bool default_value;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_default_value_enabled(bool p_enabled);
-	bool is_default_value_enabled() const;
-
-	void set_default_value(bool p_value);
-	bool get_default_value() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeBooleanUniform();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeColorUniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeColorUniform, VisualShaderNodeUniform);
-
-private:
-	bool default_value_enabled;
-	Color default_value;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_default_value_enabled(bool p_enabled);
-	bool is_default_value_enabled() const;
-
-	void set_default_value(const Color &p_value);
-	Color get_default_value() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeColorUniform();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeVec3Uniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeVec3Uniform, VisualShaderNodeUniform);
-
-private:
-	bool default_value_enabled;
-	Vector3 default_value;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_default_value_enabled(bool p_enabled);
-	bool is_default_value_enabled() const;
-
-	void set_default_value(const Vector3 &p_value);
-	Vector3 get_default_value() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeVec3Uniform();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeTransformUniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeTransformUniform, VisualShaderNodeUniform);
-
-private:
-	bool default_value_enabled;
-	Transform default_value;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_default_value_enabled(bool p_enabled);
-	bool is_default_value_enabled() const;
-
-	void set_default_value(const Transform &p_value);
-	Transform get_default_value() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeTransformUniform();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeTextureUniform : public VisualShaderNodeUniform {
-	GDCLASS(VisualShaderNodeTextureUniform, VisualShaderNodeUniform);
-
-public:
-	enum TextureType {
-		TYPE_DATA,
-		TYPE_COLOR,
-		TYPE_NORMALMAP,
-		TYPE_ANISO,
-	};
-
-	enum ColorDefault {
-		COLOR_DEFAULT_WHITE,
-		COLOR_DEFAULT_BLACK
-	};
-
-protected:
-	TextureType texture_type;
-	ColorDefault color_default;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-	virtual String get_input_port_default_hint(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	virtual bool is_code_generated() const;
-	virtual bool is_show_prop_names() const;
-
-	Vector<StringName> get_editable_properties() const;
-
-	void set_texture_type(TextureType p_type);
-	TextureType get_texture_type() const;
-
-	void set_color_default(ColorDefault p_default);
-	ColorDefault get_color_default() const;
-
-	VisualShaderNodeTextureUniform();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::TextureType)
-VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::ColorDefault)
-
-///////////////////////////////////////
-
-class VisualShaderNodeTextureUniformTriplanar : public VisualShaderNodeTextureUniform {
-	GDCLASS(VisualShaderNodeTextureUniformTriplanar, VisualShaderNodeTextureUniform);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual String get_input_port_default_hint(int p_port) const;
-
-	virtual String generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeTextureUniformTriplanar();
-};
-
-///////////////////////////////////////
-
-class VisualShaderNodeCubeMapUniform : public VisualShaderNodeTextureUniform {
-	GDCLASS(VisualShaderNodeCubeMapUniform, VisualShaderNodeTextureUniform);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String get_input_port_default_hint(int p_port) const;
-	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	VisualShaderNodeCubeMapUniform();
-};
-
-///////////////////////////////////////
-/// IF
-///////////////////////////////////////
-
-class VisualShaderNodeIf : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeIf, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeIf();
-};
-
-///////////////////////////////////////
-/// SWITCH
-///////////////////////////////////////
-
-class VisualShaderNodeSwitch : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeSwitch, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeSwitch();
-};
-
-class VisualShaderNodeScalarSwitch : public VisualShaderNodeSwitch {
-	GDCLASS(VisualShaderNodeScalarSwitch, VisualShaderNodeSwitch);
-
-public:
-	virtual String get_caption() const;
-
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual PortType get_output_port_type(int p_port) const;
-
-	VisualShaderNodeScalarSwitch();
-};
-
-///////////////////////////////////////
-/// FRESNEL
-///////////////////////////////////////
-
-class VisualShaderNodeFresnel : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeFresnel, VisualShaderNode);
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String get_input_port_default_hint(int p_port) const;
-	virtual bool is_generate_input_var(int p_port) const;
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
-
-	VisualShaderNodeFresnel();
-};
-
-///////////////////////////////////////
-/// Is
-///////////////////////////////////////
-
-class VisualShaderNodeIs : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeIs, VisualShaderNode);
-
-public:
-	enum Function {
-		FUNC_IS_INF,
-		FUNC_IS_NAN,
-	};
-
-protected:
-	Function func;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-
-	VisualShaderNodeIs();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeIs::Function)
-
-///////////////////////////////////////
-/// Compare
-///////////////////////////////////////
-
-class VisualShaderNodeCompare : public VisualShaderNode {
-	GDCLASS(VisualShaderNodeCompare, VisualShaderNode);
-
-public:
-	enum ComparisonType {
-		CTYPE_SCALAR,
-		CTYPE_VECTOR,
-		CTYPE_BOOLEAN,
-		CTYPE_TRANSFORM
-	};
-
-	enum Function {
-		FUNC_EQUAL,
-		FUNC_NOT_EQUAL,
-		FUNC_GREATER_THAN,
-		FUNC_GREATER_THAN_EQUAL,
-		FUNC_LESS_THAN,
-		FUNC_LESS_THAN_EQUAL,
-	};
-
-	enum Condition {
-		COND_ALL,
-		COND_ANY,
-	};
-
-protected:
-	ComparisonType ctype;
-	Function func;
-	Condition condition;
-
-protected:
-	static void _bind_methods();
-
-public:
-	virtual String get_caption() const;
-
-	virtual int get_input_port_count() const;
-	virtual PortType get_input_port_type(int p_port) const;
-	virtual String get_input_port_name(int p_port) const;
-
-	virtual int get_output_port_count() const;
-	virtual PortType get_output_port_type(int p_port) const;
-	virtual String get_output_port_name(int p_port) const;
-
-	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
-
-	void set_comparison_type(ComparisonType p_type);
-	ComparisonType get_comparison_type() const;
-
-	void set_function(Function p_func);
-	Function get_function() const;
-
-	void set_condition(Condition p_cond);
-	Condition get_condition() const;
-
-	virtual Vector<StringName> get_editable_properties() const;
-	virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
-
-	VisualShaderNodeCompare();
-};
-
-VARIANT_ENUM_CAST(VisualShaderNodeCompare::ComparisonType)
-VARIANT_ENUM_CAST(VisualShaderNodeCompare::Function)
-VARIANT_ENUM_CAST(VisualShaderNodeCompare::Condition)
-
-#endif // VISUAL_SHADER_NODES_H