From 5b71fc45b703d2ea44cc1aa99830ec3e0966b3e6 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Thu, 16 Jul 2015 22:38:12 -0300
Subject: Use popup menu to add new nodes to the shader graph editor in the
 last clicked location.

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 37 ++++++++++++++--------
 tools/editor/plugins/shader_graph_editor_plugin.h  |  6 ++--
 2 files changed, 27 insertions(+), 16 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 03fcbffa24..b4fb14dbbc 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -2114,7 +2114,7 @@ void ShaderGraphView::_notification(int p_what) {
 	}
  }
 
-void ShaderGraphView::add_node(int p_type) {
+void ShaderGraphView::add_node(int p_type, const Vector2 &location) {
 
 	List<int> existing;
 	graph->get_node_list(type,&existing);
@@ -2127,7 +2127,7 @@ void ShaderGraphView::add_node(int p_type) {
 		}
 	}
 
-	Vector2 init_ofs(20,20);
+    Vector2 init_ofs = location;
 	while(true) {
 		bool valid=true;
 		for(List<int>::Element *E=existing.front();E;E=E->next()) {
@@ -2222,7 +2222,17 @@ void ShaderGraphEditor::_add_node(int p_type) {
 
 	ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
 
-	graph_edits[shader_type]->add_node(p_type);
+    graph_edits[shader_type]->add_node(p_type, next_location);
+}
+
+void ShaderGraphEditor::_popup_requested(const Vector2 &p_position)
+{
+    next_location = get_local_mouse_pos();
+    popup->set_global_pos(p_position);
+    popup->set_size( Size2( 200, 0) );
+    popup->popup();
+    popup->call_deferred("grab_click_focus");
+    popup->set_invalidate_click_until_motion();
 }
 
 
@@ -2243,11 +2253,11 @@ void ShaderGraphEditor::_notification(int p_what) {
 			if (nn.ends_with(":")) {
 				addsep=true;
 			}
-			menu->get_popup()->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
+            popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
 			if (addsep)
-				menu->get_popup()->add_separator();
+                popup->add_separator();
 		}
-		menu->get_popup()->connect("item_pressed",this,"_add_node");
+        popup->connect("item_pressed",this,"_add_node");
 
 
 	}
@@ -2256,7 +2266,7 @@ void ShaderGraphEditor::_notification(int p_what) {
 void ShaderGraphEditor::_bind_methods() {
 
 	ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
-
+    ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
 }
 
 
@@ -2302,11 +2312,10 @@ const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
 ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
 	_2d=p_2d;
 
-	HBoxContainer *hbc = memnew( HBoxContainer );
-	menu = memnew( MenuButton );
-	menu->set_text("Add Node..");
-	hbc->add_child(menu);
-	add_child(hbc);
+    HBoxContainer *hbc = memnew( HBoxContainer );
+    popup = memnew( PopupMenu );
+    hbc->add_child(popup);
+    add_child(hbc);
 
 
 	tabs = memnew(TabContainer);
@@ -2325,8 +2334,8 @@ ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
 		tabs->add_child(graph_edits[i]->get_graph_edit());
 		graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
 		graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
-		graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
-
+        graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
+        graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
 	}
 
 	tabs->set_current_tab(1);
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index 0051fbfd74..c41ec68360 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -175,7 +175,7 @@ protected:
 	static void _bind_methods();
 public:
 
-	void add_node(int p_type);
+    void add_node(int p_type, const Vector2 &location);
 	GraphEdit *get_graph_edit() { return graph_edit; }
 	void set_graph(Ref<ShaderGraph> p_graph);
 
@@ -186,13 +186,15 @@ class ShaderGraphEditor : public VBoxContainer {
 
 	OBJ_TYPE(ShaderGraphEditor,VBoxContainer);
 
-	MenuButton *menu;
+    PopupMenu *popup;
 	TabContainer *tabs;
 	ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
 	static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
+    Vector2 next_location;
 
 	bool _2d;
 	void _add_node(int p_type);
+    void _popup_requested(const Vector2 &p_position);
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
-- 
cgit v1.2.3


From bdd12744fe340152cef5bf88de9e2d183bff1790 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sun, 19 Jul 2015 01:48:46 -0300
Subject: Select and move multiple nodes at once

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 3779 ++++++++++----------
 tools/editor/plugins/shader_graph_editor_plugin.h  |  244 +-
 2 files changed, 2020 insertions(+), 2003 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index b4fb14dbbc..a0f7edbd93 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -37,596 +37,596 @@
 
 void GraphColorRampEdit::_input_event(const InputEvent& p_event) {
 
-	if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
-
-		points.remove(grabbed);
-		grabbed=-1;
-		update();
-		emit_signal("ramp_changed");
-		accept_event();
-	}
-
-	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+        if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
+
+                points.remove(grabbed);
+                grabbed=-1;
+                update();
+                emit_signal("ramp_changed");
+                accept_event();
+        }
+
+        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
 
-		update();
-		int x = p_event.mouse_button.x;
-		int total_w = get_size().width-get_size().height-3;
-		if (x>total_w+3) {
-
-			if (grabbed==-1)
-				return;
-			Size2 ms = Size2(350, picker->get_combined_minimum_size().height+10);
-			picker->set_color(points[grabbed].color);
-			popup->set_pos(get_global_pos()-Size2(0,ms.height));
-			popup->set_size(ms);
-			popup->popup();
-			return;
-		}
-
-
-		float ofs = CLAMP(x/float(total_w),0,1);
-
-		grabbed=-1;
-		grabbing=true;
-		int pos=-1;
-		for(int i=0;i<points.size();i++) {
+                update();
+                int x = p_event.mouse_button.x;
+                int total_w = get_size().width-get_size().height-3;
+                if (x>total_w+3) {
+
+                        if (grabbed==-1)
+                                return;
+                        Size2 ms = Size2(350, picker->get_combined_minimum_size().height+10);
+                        picker->set_color(points[grabbed].color);
+                        popup->set_pos(get_global_pos()-Size2(0,ms.height));
+                        popup->set_size(ms);
+                        popup->popup();
+                        return;
+                }
+
+
+                float ofs = CLAMP(x/float(total_w),0,1);
+
+                grabbed=-1;
+                grabbing=true;
+                int pos=-1;
+                for(int i=0;i<points.size();i++) {
 
-			if (ABS(x-points[i].offset*total_w)<4) {
-				grabbed=i;
-			}
-			if (points[i].offset<ofs)
-				pos=i;
-		}
+                        if (ABS(x-points[i].offset*total_w)<4) {
+                                grabbed=i;
+                        }
+                        if (points[i].offset<ofs)
+                                pos=i;
+                }
 
-		grabbed_at=ofs;
-		//grab or select
-		if (grabbed!=-1) {
-			return;
-		}
-		//insert
+                grabbed_at=ofs;
+                //grab or select
+                if (grabbed!=-1) {
+                        return;
+                }
+                //insert
 
 
-		Point p;
-		p.offset=ofs;
+                Point p;
+                p.offset=ofs;
 
-		Point prev;
-		Point next;
+                Point prev;
+                Point next;
 
-		if (pos==-1) {
+                if (pos==-1) {
 
-			prev.color=Color(0,0,0);
-			prev.offset=0;
-			if (points.size()) {
-				next=points[0];
-			} else {
-				next.color=Color(1,1,1);
-				next.offset=1.0;
-			}
-		} else  {
+                        prev.color=Color(0,0,0);
+                        prev.offset=0;
+                        if (points.size()) {
+                                next=points[0];
+                        } else {
+                                next.color=Color(1,1,1);
+                                next.offset=1.0;
+                        }
+                } else  {
 
-			if (pos==points.size()-1) {
-				next.color=Color(1,1,1);
-				next.offset=1.0;
-			} else {
-				next=points[pos+1];
-			}
-			prev=points[pos];
+                        if (pos==points.size()-1) {
+                                next.color=Color(1,1,1);
+                                next.offset=1.0;
+                        } else {
+                                next=points[pos+1];
+                        }
+                        prev=points[pos];
 
-		}
+                }
 
-		p.color=prev.color.linear_interpolate(next.color,(p.offset-prev.offset)/(next.offset-prev.offset));
+                p.color=prev.color.linear_interpolate(next.color,(p.offset-prev.offset)/(next.offset-prev.offset));
 
-		points.push_back(p);
-		points.sort();
-		for(int i=0;i<points.size();i++) {
-			if (points[i].offset==ofs) {
-				grabbed=i;
-				break;
-			}
-		}
+                points.push_back(p);
+                points.sort();
+                for(int i=0;i<points.size();i++) {
+                        if (points[i].offset==ofs) {
+                                grabbed=i;
+                                break;
+                        }
+                }
 
-		emit_signal("ramp_changed");
+                emit_signal("ramp_changed");
 
-	}
+        }
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
+        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
 
-		if (grabbing) {
-			grabbing=false;
-			emit_signal("ramp_changed");
-		}
-		update();
-	}
+                if (grabbing) {
+                        grabbing=false;
+                        emit_signal("ramp_changed");
+                }
+                update();
+        }
 
-	if (p_event.type==InputEvent::MOUSE_MOTION && grabbing) {
+        if (p_event.type==InputEvent::MOUSE_MOTION && grabbing) {
 
-		int total_w = get_size().width-get_size().height-3;
+                int total_w = get_size().width-get_size().height-3;
 
-		int x = p_event.mouse_motion.x;
-		float newofs = CLAMP(x/float(total_w),0,1);
+                int x = p_event.mouse_motion.x;
+                float newofs = CLAMP(x/float(total_w),0,1);
 
-		bool valid=true;
-		for(int i=0;i<points.size();i++) {
+                bool valid=true;
+                for(int i=0;i<points.size();i++) {
 
-			if (points[i].offset==newofs && i!=grabbed) {
-				valid=false;
-			}
-		}
+                        if (points[i].offset==newofs && i!=grabbed) {
+                                valid=false;
+                        }
+                }
 
-		if (!valid)
-			return;
+                if (!valid)
+                        return;
 
-		points[grabbed].offset=newofs;
+                points[grabbed].offset=newofs;
 
-		points.sort();
-		for(int i=0;i<points.size();i++) {
-			if (points[i].offset==newofs) {
-				grabbed=i;
-				break;
-			}
-		}
+                points.sort();
+                for(int i=0;i<points.size();i++) {
+                        if (points[i].offset==newofs) {
+                                grabbed=i;
+                                break;
+                        }
+                }
 
-		emit_signal("ramp_changed");
+                emit_signal("ramp_changed");
 
-		update();
-	}
+                update();
+        }
 }
 
 void GraphColorRampEdit::_notification(int p_what){
 
-	if (p_what==NOTIFICATION_ENTER_TREE) {
-		picker->connect("color_changed",this,"_color_changed");
-	}
-	if (p_what==NOTIFICATION_DRAW) {
+        if (p_what==NOTIFICATION_ENTER_TREE) {
+                picker->connect("color_changed",this,"_color_changed");
+        }
+        if (p_what==NOTIFICATION_DRAW) {
 
 
-		Point prev;
-		prev.offset=0;
-		prev.color=Color(0,0,0);
-		int w = get_size().x;
-		int h = get_size().y;
+                Point prev;
+                prev.offset=0;
+                prev.color=Color(0,0,0);
+                int w = get_size().x;
+                int h = get_size().y;
 
-		int total_w = get_size().width-get_size().height-3;
+                int total_w = get_size().width-get_size().height-3;
 
-		for(int i=-1;i<points.size();i++) {
+                for(int i=-1;i<points.size();i++) {
 
-			Point next;
-			if (i+1==points.size()) {
-				next.color=Color(1,1,1);
-				next.offset=1;
-			} else {
-				next=points[i+1];
-			}
+                        Point next;
+                        if (i+1==points.size()) {
+                                next.color=Color(1,1,1);
+                                next.offset=1;
+                        } else {
+                                next=points[i+1];
+                        }
 
-			if (prev.offset==next.offset) {
-				prev=next;
-				continue;
-			}
+                        if (prev.offset==next.offset) {
+                                prev=next;
+                                continue;
+                        }
 
-			Vector<Vector2> points;
-			Vector<Color> colors;
-			points.push_back(Vector2(prev.offset*total_w,h));
-			points.push_back(Vector2(prev.offset*total_w,0));
-			points.push_back(Vector2(next.offset*total_w,0));
-			points.push_back(Vector2(next.offset*total_w,h));
-			colors.push_back(prev.color);
-			colors.push_back(prev.color);
-			colors.push_back(next.color);
-			colors.push_back(next.color);
-			draw_primitive(points,colors,Vector<Point2>());
-			prev=next;
-		}
+                        Vector<Vector2> points;
+                        Vector<Color> colors;
+                        points.push_back(Vector2(prev.offset*total_w,h));
+                        points.push_back(Vector2(prev.offset*total_w,0));
+                        points.push_back(Vector2(next.offset*total_w,0));
+                        points.push_back(Vector2(next.offset*total_w,h));
+                        colors.push_back(prev.color);
+                        colors.push_back(prev.color);
+                        colors.push_back(next.color);
+                        colors.push_back(next.color);
+                        draw_primitive(points,colors,Vector<Point2>());
+                        prev=next;
+                }
 
-		for(int i=0;i<points.size();i++) {
+                for(int i=0;i<points.size();i++) {
 
-			Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
+                        Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
 
-			draw_line(Vector2(points[i].offset*total_w,0),Vector2(points[i].offset*total_w,h-1),Color(0,0,0,0.7));
-			draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w-1,h-1),col);
-			draw_line(Vector2(points[i].offset*total_w+1,h/2),Vector2(points[i].offset*total_w+1,h-1),col);
-			draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w+1,h/2),col);
-			draw_line(Vector2(points[i].offset*total_w-1,h-1),Vector2(points[i].offset*total_w+1,h-1),col);
+                        draw_line(Vector2(points[i].offset*total_w,0),Vector2(points[i].offset*total_w,h-1),Color(0,0,0,0.7));
+                        draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w-1,h-1),col);
+                        draw_line(Vector2(points[i].offset*total_w+1,h/2),Vector2(points[i].offset*total_w+1,h-1),col);
+                        draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w+1,h/2),col);
+                        draw_line(Vector2(points[i].offset*total_w-1,h-1),Vector2(points[i].offset*total_w+1,h-1),col);
 
-		}
+                }
 
-		if (grabbed!=-1) {
+                if (grabbed!=-1) {
 
-			draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
-		}
+                        draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
+                }
 
-		if (has_focus()) {
+                if (has_focus()) {
 
-			draw_line(Vector2(-1,-1),Vector2(total_w+1,-1),Color(1,1,1,0.6));
-			draw_line(Vector2(total_w+1,-1),Vector2(total_w+1,h+1),Color(1,1,1,0.6));
-			draw_line(Vector2(total_w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
-			draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
-		}
+                        draw_line(Vector2(-1,-1),Vector2(total_w+1,-1),Color(1,1,1,0.6));
+                        draw_line(Vector2(total_w+1,-1),Vector2(total_w+1,h+1),Color(1,1,1,0.6));
+                        draw_line(Vector2(total_w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
+                        draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
+                }
 
-	}
+        }
 }
 
 Size2 GraphColorRampEdit::get_minimum_size() const {
 
-	return Vector2(0,16);
+        return Vector2(0,16);
 }
 
 
 void GraphColorRampEdit::_color_changed(const Color& p_color) {
 
-	if (grabbed==-1)
-		return;
-	points[grabbed].color=p_color;
-	update();
-	emit_signal("ramp_changed");
+        if (grabbed==-1)
+                return;
+        points[grabbed].color=p_color;
+        update();
+        emit_signal("ramp_changed");
 
 }
 
 void GraphColorRampEdit::set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors) {
 
-	ERR_FAIL_COND(p_offsets.size()!=p_colors.size());
-	points.clear();
-	for(int i=0;i<p_offsets.size();i++) {
-		Point p;
-		p.offset=p_offsets[i];
-		p.color=p_colors[i];
-		points.push_back(p);
-	}
+        ERR_FAIL_COND(p_offsets.size()!=p_colors.size());
+        points.clear();
+        for(int i=0;i<p_offsets.size();i++) {
+                Point p;
+                p.offset=p_offsets[i];
+                p.color=p_colors[i];
+                points.push_back(p);
+        }
 
-	points.sort();
-	update();
+        points.sort();
+        update();
 }
 
 Vector<float> GraphColorRampEdit::get_offsets() const{
-	Vector<float> ret;
-	for(int i=0;i<points.size();i++)
-		ret.push_back(points[i].offset);
-	return ret;
+        Vector<float> ret;
+        for(int i=0;i<points.size();i++)
+                ret.push_back(points[i].offset);
+        return ret;
 }
 Vector<Color> GraphColorRampEdit::get_colors() const{
 
-	Vector<Color> ret;
-	for(int i=0;i<points.size();i++)
-		ret.push_back(points[i].color);
-	return ret;
+        Vector<Color> ret;
+        for(int i=0;i<points.size();i++)
+                ret.push_back(points[i].color);
+        return ret;
 }
 
 
 void GraphColorRampEdit::_bind_methods(){
 
-	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphColorRampEdit::_input_event);
-	ObjectTypeDB::bind_method(_MD("_color_changed"),&GraphColorRampEdit::_color_changed);
-	ADD_SIGNAL(MethodInfo("ramp_changed"));
+        ObjectTypeDB::bind_method(_MD("_input_event"),&GraphColorRampEdit::_input_event);
+        ObjectTypeDB::bind_method(_MD("_color_changed"),&GraphColorRampEdit::_color_changed);
+        ADD_SIGNAL(MethodInfo("ramp_changed"));
 }
 
 GraphColorRampEdit::GraphColorRampEdit(){
 
-	grabbed=-1;
-	grabbing=false;
-	set_focus_mode(FOCUS_ALL);
+        grabbed=-1;
+        grabbing=false;
+        set_focus_mode(FOCUS_ALL);
 
-	popup = memnew( PopupPanel );
-	picker = memnew( ColorPicker );
-	popup->add_child(picker);
-	popup->set_child_rect(picker);
-	add_child(popup);
+        popup = memnew( PopupPanel );
+        picker = memnew( ColorPicker );
+        popup->add_child(picker);
+        popup->set_child_rect(picker);
+        add_child(popup);
 
 }
 ////////////
 
 void GraphCurveMapEdit::_input_event(const InputEvent& p_event) {
 
-	if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
+        if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
 
-		points.remove(grabbed);
-		grabbed=-1;
-		update();
-		emit_signal("curve_changed");
-		accept_event();
-	}
+                points.remove(grabbed);
+                grabbed=-1;
+                update();
+                emit_signal("curve_changed");
+                accept_event();
+        }
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
 
-		update();
-		Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
-		p.y=1.0-p.y;
-		grabbed=-1;
-		grabbing=true;
+                update();
+                Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
+                p.y=1.0-p.y;
+                grabbed=-1;
+                grabbing=true;
 
-		for(int i=0;i<points.size();i++) {
+                for(int i=0;i<points.size();i++) {
 
-			Vector2 ps = p*get_size();
-			Vector2 pt = Vector2(points[i].offset,points[i].height)*get_size();
-			if (ps.distance_to(pt)<4) {
-				grabbed=i;
-			}
+                        Vector2 ps = p*get_size();
+                        Vector2 pt = Vector2(points[i].offset,points[i].height)*get_size();
+                        if (ps.distance_to(pt)<4) {
+                                grabbed=i;
+                        }
 
-		}
+                }
 
 
-		//grab or select
-		if (grabbed!=-1) {
-			return;
-		}
-		//insert
+                //grab or select
+                if (grabbed!=-1) {
+                        return;
+                }
+                //insert
 
 
-		Point np;
-		np.offset=p.x;
-		np.height=p.y;
+                Point np;
+                np.offset=p.x;
+                np.height=p.y;
 
-		points.push_back(np);
-		points.sort();
-		for(int i=0;i<points.size();i++) {
-			if (points[i].offset==p.x && points[i].height==p.y) {
-				grabbed=i;
-				break;
-			}
-		}
+                points.push_back(np);
+                points.sort();
+                for(int i=0;i<points.size();i++) {
+                        if (points[i].offset==p.x && points[i].height==p.y) {
+                                grabbed=i;
+                                break;
+                        }
+                }
 
-		emit_signal("curve_changed");
+                emit_signal("curve_changed");
 
-	}
+        }
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
+        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
 
-		if (grabbing) {
-			grabbing=false;
-			emit_signal("curve_changed");
-		}
-		update();
-	}
+                if (grabbing) {
+                        grabbing=false;
+                        emit_signal("curve_changed");
+                }
+                update();
+        }
 
-	if (p_event.type==InputEvent::MOUSE_MOTION && grabbing  && grabbed != -1) {
+        if (p_event.type==InputEvent::MOUSE_MOTION && grabbing  && grabbed != -1) {
 
-		Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
-		p.y=1.0-p.y;
+                Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
+                p.y=1.0-p.y;
 
-		p.x = CLAMP(p.x,0.0,1.0);
-		p.y = CLAMP(p.y,0.0,1.0);
+                p.x = CLAMP(p.x,0.0,1.0);
+                p.y = CLAMP(p.y,0.0,1.0);
 
-		bool valid=true;
+                bool valid=true;
 
-		for(int i=0;i<points.size();i++) {
+                for(int i=0;i<points.size();i++) {
 
-			if (points[i].offset==p.x && points[i].height==p.y && i!=grabbed) {
-				valid=false;
-			}
-		}
+                        if (points[i].offset==p.x && points[i].height==p.y && i!=grabbed) {
+                                valid=false;
+                        }
+                }
 
-		if (!valid)
-			return;
+                if (!valid)
+                        return;
 
-		points[grabbed].offset=p.x;
-		points[grabbed].height=p.y;
+                points[grabbed].offset=p.x;
+                points[grabbed].height=p.y;
 
-		points.sort();
-		for(int i=0;i<points.size();i++) {
-			if (points[i].offset==p.x && points[i].height==p.y) {
-				grabbed=i;
-				break;
-			}
-		}
+                points.sort();
+                for(int i=0;i<points.size();i++) {
+                        if (points[i].offset==p.x && points[i].height==p.y) {
+                                grabbed=i;
+                                break;
+                        }
+                }
 
-		emit_signal("curve_changed");
+                emit_signal("curve_changed");
 
-		update();
-	}
+                update();
+        }
 }
 
 void GraphCurveMapEdit::_plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d) {
 
-	float geometry[4][4];
-	float tmp1[4][4];
-	float tmp2[4][4];
-	float deltas[4][4];
-	double x, dx, dx2, dx3;
-	double y, dy, dy2, dy3;
-	double d, d2, d3;
-	int lastx, lasty;
-	int newx, newy;
-	int ntimes;
-	int i,j;
-
-	int xmax=get_size().x;
-	int ymax=get_size().y;
-
-	/* construct the geometry matrix from the segment */
-	for (i = 0; i < 4; i++)	{
-		geometry[i][2] = 0;
-		geometry[i][3] = 0;
-	}
-
-	geometry[0][0] = (p_a[0] * xmax);
-	geometry[1][0] = (p_b[0] * xmax);
-	geometry[2][0] = (p_c[0] * xmax);
-	geometry[3][0] = (p_d[0] * xmax);
-
-	geometry[0][1] = (p_a[1] * ymax);
-	geometry[1][1] = (p_b[1] * ymax);
-	geometry[2][1] = (p_c[1] * ymax);
-	geometry[3][1] = (p_d[1] * ymax);
-
-	/* subdivide the curve ntimes (1000) times */
-	ntimes = 4 * xmax;
-	/* ntimes can be adjusted to give a finer or coarser curve */
-	d = 1.0 / ntimes;
-	d2 = d * d;
-	d3 = d * d * d;
-
-	/* construct a temporary matrix for determining the forward differencing deltas */
-	tmp2[0][0] = 0;     tmp2[0][1] = 0;     tmp2[0][2] = 0;    tmp2[0][3] = 1;
-	tmp2[1][0] = d3;    tmp2[1][1] = d2;    tmp2[1][2] = d;    tmp2[1][3] = 0;
-	tmp2[2][0] = 6*d3;  tmp2[2][1] = 2*d2;  tmp2[2][2] = 0;    tmp2[2][3] = 0;
-	tmp2[3][0] = 6*d3;  tmp2[3][1] = 0;     tmp2[3][2] = 0;    tmp2[3][3] = 0;
-
-	/* compose the basis and geometry matrices */
-
-	static const float CR_basis[4][4] =
-	{
-	  { -0.5,  1.5, -1.5,  0.5 },
-	  {  1.0, -2.5,  2.0, -0.5 },
-	  { -0.5,  0.0,  0.5,  0.0 },
-	  {  0.0,  1.0,  0.0,  0.0 },
-	};
-
-	for (i = 0; i < 4; i++)
-	    {
-	      for (j = 0; j < 4; j++)
-		{
-		  tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] +
-			      CR_basis[i][1] * geometry[1][j] +
-			      CR_basis[i][2] * geometry[2][j] +
-			      CR_basis[i][3] * geometry[3][j]);
-		}
-	    }
-	/* compose the above results to get the deltas matrix */
-
-	for (i = 0; i < 4; i++)
-	    {
-	      for (j = 0; j < 4; j++)
-		{
-		  deltas[i][j] = (tmp2[i][0] * tmp1[0][j] +
-			      tmp2[i][1] * tmp1[1][j] +
-			      tmp2[i][2] * tmp1[2][j] +
-			      tmp2[i][3] * tmp1[3][j]);
-		}
-	    }
-
-
-	/* extract the x deltas */
-	x = deltas[0][0];
-	dx = deltas[1][0];
-	dx2 = deltas[2][0];
-	dx3 = deltas[3][0];
-
-	/* extract the y deltas */
-	y = deltas[0][1];
-	dy = deltas[1][1];
-	dy2 = deltas[2][1];
-	dy3 = deltas[3][1];
-
-
-	lastx = CLAMP (x, 0, xmax);
-	lasty = CLAMP (y, 0, ymax);
+        float geometry[4][4];
+        float tmp1[4][4];
+        float tmp2[4][4];
+        float deltas[4][4];
+        double x, dx, dx2, dx3;
+        double y, dy, dy2, dy3;
+        double d, d2, d3;
+        int lastx, lasty;
+        int newx, newy;
+        int ntimes;
+        int i,j;
+
+        int xmax=get_size().x;
+        int ymax=get_size().y;
+
+        /* construct the geometry matrix from the segment */
+        for (i = 0; i < 4; i++)	{
+                geometry[i][2] = 0;
+                geometry[i][3] = 0;
+        }
+
+        geometry[0][0] = (p_a[0] * xmax);
+        geometry[1][0] = (p_b[0] * xmax);
+        geometry[2][0] = (p_c[0] * xmax);
+        geometry[3][0] = (p_d[0] * xmax);
+
+        geometry[0][1] = (p_a[1] * ymax);
+        geometry[1][1] = (p_b[1] * ymax);
+        geometry[2][1] = (p_c[1] * ymax);
+        geometry[3][1] = (p_d[1] * ymax);
+
+        /* subdivide the curve ntimes (1000) times */
+        ntimes = 4 * xmax;
+        /* ntimes can be adjusted to give a finer or coarser curve */
+        d = 1.0 / ntimes;
+        d2 = d * d;
+        d3 = d * d * d;
+
+        /* construct a temporary matrix for determining the forward differencing deltas */
+        tmp2[0][0] = 0;		 tmp2[0][1] = 0;		 tmp2[0][2] = 0;		tmp2[0][3] = 1;
+        tmp2[1][0] = d3;		tmp2[1][1] = d2;		tmp2[1][2] = d;		tmp2[1][3] = 0;
+        tmp2[2][0] = 6*d3;  tmp2[2][1] = 2*d2;  tmp2[2][2] = 0;		tmp2[2][3] = 0;
+        tmp2[3][0] = 6*d3;  tmp2[3][1] = 0;		 tmp2[3][2] = 0;		tmp2[3][3] = 0;
+
+        /* compose the basis and geometry matrices */
+
+        static const float CR_basis[4][4] =
+        {
+          { -0.5,  1.5, -1.5,  0.5 },
+          {  1.0, -2.5,  2.0, -0.5 },
+          { -0.5,  0.0,  0.5,  0.0 },
+          {  0.0,  1.0,  0.0,  0.0 },
+        };
+
+        for (i = 0; i < 4; i++)
+                {
+                  for (j = 0; j < 4; j++)
+                {
+                  tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] +
+                                  CR_basis[i][1] * geometry[1][j] +
+                                  CR_basis[i][2] * geometry[2][j] +
+                                  CR_basis[i][3] * geometry[3][j]);
+                }
+                }
+        /* compose the above results to get the deltas matrix */
+
+        for (i = 0; i < 4; i++)
+                {
+                  for (j = 0; j < 4; j++)
+                {
+                  deltas[i][j] = (tmp2[i][0] * tmp1[0][j] +
+                                  tmp2[i][1] * tmp1[1][j] +
+                                  tmp2[i][2] * tmp1[2][j] +
+                                  tmp2[i][3] * tmp1[3][j]);
+                }
+                }
+
+
+        /* extract the x deltas */
+        x = deltas[0][0];
+        dx = deltas[1][0];
+        dx2 = deltas[2][0];
+        dx3 = deltas[3][0];
+
+        /* extract the y deltas */
+        y = deltas[0][1];
+        dy = deltas[1][1];
+        dy2 = deltas[2][1];
+        dy3 = deltas[3][1];
+
+
+        lastx = CLAMP (x, 0, xmax);
+        lasty = CLAMP (y, 0, ymax);
 
 /*	if (fix255)
-	{
-		cd->curve[cd->outline][lastx] = lasty;
-	}
-	else
-	{
-		cd->curve_ptr[cd->outline][lastx] = lasty;
-		if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax);
-	}
+        {
+                cd->curve[cd->outline][lastx] = lasty;
+        }
+        else
+        {
+                cd->curve_ptr[cd->outline][lastx] = lasty;
+                if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax);
+        }
 */
-	/* loop over the curve */
-	for (i = 0; i < ntimes; i++)
-	{
-		/* increment the x values */
-		x += dx;
-		dx += dx2;
-		dx2 += dx3;
-
-		/* increment the y values */
-		y += dy;
-		dy += dy2;
-		dy2 += dy3;
-
-		newx = CLAMP ((Math::round (x)), 0, xmax);
-		newy = CLAMP ((Math::round (y)), 0, ymax);
-
-		/* if this point is different than the last one...then draw it */
-		if ((lastx != newx) || (lasty != newy))
-		{
+        /* loop over the curve */
+        for (i = 0; i < ntimes; i++)
+        {
+                /* increment the x values */
+                x += dx;
+                dx += dx2;
+                dx2 += dx3;
+
+                /* increment the y values */
+                y += dy;
+                dy += dy2;
+                dy2 += dy3;
+
+                newx = CLAMP ((Math::round (x)), 0, xmax);
+                newy = CLAMP ((Math::round (y)), 0, ymax);
+
+                /* if this point is different than the last one...then draw it */
+                if ((lastx != newx) || (lasty != newy))
+                {
 #if 0
-			if(fix255)
-			{
-				/* use fixed array size (for the curve graph) */
-				cd->curve[cd->outline][newx] = newy;
-			}
-			else
-			{
-				/* use dynamic allocated curve_ptr (for the real curve) */
-				cd->curve_ptr[cd->outline][newx] = newy;
-
-				if(gb_debug) printf("outline: %d  cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy);
-			}
+                        if(fix255)
+                        {
+                                /* use fixed array size (for the curve graph) */
+                                cd->curve[cd->outline][newx] = newy;
+                        }
+                        else
+                        {
+                                /* use dynamic allocated curve_ptr (for the real curve) */
+                                cd->curve_ptr[cd->outline][newx] = newy;
+
+                                if(gb_debug) printf("outline: %d  cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy);
+                        }
 #endif
-			draw_line(Vector2(lastx,ymax-lasty),Vector2(newx,ymax-newy),Color(0.8,0.8,0.8,0.8),2.0);
-		}
+                        draw_line(Vector2(lastx,ymax-lasty),Vector2(newx,ymax-newy),Color(0.8,0.8,0.8,0.8),2.0);
+                }
 
-		lastx = newx;
-		lasty = newy;
-	}
+                lastx = newx;
+                lasty = newy;
+        }
 }
 
 
 void GraphCurveMapEdit::_notification(int p_what){
 
-	if (p_what==NOTIFICATION_DRAW) {
+        if (p_what==NOTIFICATION_DRAW) {
 
-		draw_style_box(get_stylebox("bg","Tree"),Rect2(Point2(),get_size()));
+                draw_style_box(get_stylebox("bg","Tree"),Rect2(Point2(),get_size()));
 
-		int w = get_size().x;
-		int h = get_size().y;
+                int w = get_size().x;
+                int h = get_size().y;
 
-		Vector2 prev=Vector2(0,0);
-		Vector2 prev2=Vector2(0,0);
+                Vector2 prev=Vector2(0,0);
+                Vector2 prev2=Vector2(0,0);
 
-		for(int i=-1;i<points.size();i++) {
+                for(int i=-1;i<points.size();i++) {
 
-			Vector2 next;
-			Vector2 next2;
-			if (i+1>=points.size()) {
-				next=Vector2(1,1);
-			} else {
-				next=Vector2(points[i+1].offset,points[i+1].height);
-			}
+                        Vector2 next;
+                        Vector2 next2;
+                        if (i+1>=points.size()) {
+                                next=Vector2(1,1);
+                        } else {
+                                next=Vector2(points[i+1].offset,points[i+1].height);
+                        }
 
-			if (i+2>=points.size()) {
-				next2=Vector2(1,1);
-			} else {
-				next2=Vector2(points[i+2].offset,points[i+2].height);
-			}
+                        if (i+2>=points.size()) {
+                                next2=Vector2(1,1);
+                        } else {
+                                next2=Vector2(points[i+2].offset,points[i+2].height);
+                        }
 
-			/*if (i==-1 && prev.offset==next.offset) {
-				prev=next;
-				continue;
-			}*/
+                        /*if (i==-1 && prev.offset==next.offset) {
+                                prev=next;
+                                continue;
+                        }*/
 
-			_plot_curve(prev2,prev,next,next2);
+                        _plot_curve(prev2,prev,next,next2);
 
-			prev2=prev;
-			prev=next;
-		}
+                        prev2=prev;
+                        prev=next;
+                }
 
-		for(int i=0;i<points.size();i++) {
+                for(int i=0;i<points.size();i++) {
 
-			Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
+                        Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
 
 
-			draw_rect(Rect2( Vector2(points[i].offset,1.0-points[i].height)*get_size()-Vector2(2,2),Vector2(5,5)),col);
-		}
+                        draw_rect(Rect2( Vector2(points[i].offset,1.0-points[i].height)*get_size()-Vector2(2,2),Vector2(5,5)),col);
+                }
 
 /*		if (grabbed!=-1) {
 
-			draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
-		}
+                        draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
+                }
 */
-		if (has_focus()) {
+                if (has_focus()) {
 
-			draw_line(Vector2(-1,-1),Vector2(w+1,-1),Color(1,1,1,0.6));
-			draw_line(Vector2(w+1,-1),Vector2(w+1,h+1),Color(1,1,1,0.6));
-			draw_line(Vector2(w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
-			draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
-		}
+                        draw_line(Vector2(-1,-1),Vector2(w+1,-1),Color(1,1,1,0.6));
+                        draw_line(Vector2(w+1,-1),Vector2(w+1,h+1),Color(1,1,1,0.6));
+                        draw_line(Vector2(w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
+                        draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
+                }
 
-	}
+        }
 }
 
 Size2 GraphCurveMapEdit::get_minimum_size() const {
 
-	return Vector2(64,64);
+        return Vector2(64,64);
 }
 
 
@@ -634,36 +634,36 @@ Size2 GraphCurveMapEdit::get_minimum_size() const {
 void GraphCurveMapEdit::set_points(const Vector<Vector2>& p_points) {
 
 
-	points.clear();
-	for(int i=0;i<p_points.size();i++) {
-		Point p;
-		p.offset=p_points[i].x;
-		p.height=p_points[i].y;
-		points.push_back(p);
-	}
+        points.clear();
+        for(int i=0;i<p_points.size();i++) {
+                Point p;
+                p.offset=p_points[i].x;
+                p.height=p_points[i].y;
+                points.push_back(p);
+        }
 
-	points.sort();
-	update();
+        points.sort();
+        update();
 }
 
 Vector<Vector2> GraphCurveMapEdit::get_points() const {
-	Vector<Vector2> ret;
-	for(int i=0;i<points.size();i++)
-		ret.push_back(Vector2(points[i].offset,points[i].height));
-	return ret;
+        Vector<Vector2> ret;
+        for(int i=0;i<points.size();i++)
+                ret.push_back(Vector2(points[i].offset,points[i].height));
+        return ret;
 }
 
 void GraphCurveMapEdit::_bind_methods(){
 
-	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphCurveMapEdit::_input_event);
-	ADD_SIGNAL(MethodInfo("curve_changed"));
+        ObjectTypeDB::bind_method(_MD("_input_event"),&GraphCurveMapEdit::_input_event);
+        ADD_SIGNAL(MethodInfo("curve_changed"));
 }
 
 GraphCurveMapEdit::GraphCurveMapEdit(){
 
-	grabbed=-1;
-	grabbing=false;
-	set_focus_mode(FOCUS_ALL);
+        grabbed=-1;
+        grabbing=false;
+        set_focus_mode(FOCUS_ALL);
 
 }
 
@@ -672,201 +672,201 @@ GraphCurveMapEdit::GraphCurveMapEdit(){
 ///
 void ShaderGraphView::_scalar_const_changed(double p_value,int p_id) {
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Scalar Constant",true);
-	ur->add_do_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,p_value);
-	ur->add_undo_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,graph->scalar_const_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Scalar Constant",true);
+        ur->add_do_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,p_value);
+        ur->add_undo_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,graph->scalar_const_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 
 void ShaderGraphView::_vec_const_changed(double p_value, int p_id,Array p_arr){
 
-	Vector3 val;
-	for(int i=0;i<p_arr.size();i++) {
-		val[i]=p_arr[i].call("get_val");
-	}
+        Vector3 val;
+        for(int i=0;i<p_arr.size();i++) {
+                val[i]=p_arr[i].call("get_val");
+        }
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Vec Constant",true);
-	ur->add_do_method(graph.ptr(),"vec_const_node_set_value",type,p_id,val);
-	ur->add_undo_method(graph.ptr(),"vec_const_node_set_value",type,p_id,graph->vec_const_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Vec Constant",true);
+        ur->add_do_method(graph.ptr(),"vec_const_node_set_value",type,p_id,val);
+        ur->add_undo_method(graph.ptr(),"vec_const_node_set_value",type,p_id,graph->vec_const_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_rgb_const_changed(const Color& p_color, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change RGB Constant",true);
-	ur->add_do_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,p_color);
-	ur->add_undo_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,graph->rgb_const_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change RGB Constant",true);
+        ur->add_do_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,p_color);
+        ur->add_undo_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,graph->rgb_const_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_scalar_op_changed(int p_op, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Scalar Operator");
-	ur->add_do_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,p_op);
-	ur->add_undo_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,graph->scalar_op_node_get_op(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Scalar Operator");
+        ur->add_do_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,p_op);
+        ur->add_undo_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,graph->scalar_op_node_get_op(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_vec_op_changed(int p_op, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Vec Operator");
-	ur->add_do_method(graph.ptr(),"vec_op_node_set_op",type,p_id,p_op);
-	ur->add_undo_method(graph.ptr(),"vec_op_node_set_op",type,p_id,graph->vec_op_node_get_op(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Vec Operator");
+        ur->add_do_method(graph.ptr(),"vec_op_node_set_op",type,p_id,p_op);
+        ur->add_undo_method(graph.ptr(),"vec_op_node_set_op",type,p_id,graph->vec_op_node_get_op(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 void ShaderGraphView::_vec_scalar_op_changed(int p_op, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change VecxScalar Operator");
-	ur->add_do_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,p_op);
-	ur->add_undo_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,graph->vec_scalar_op_node_get_op(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change VecxScalar Operator");
+        ur->add_do_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,p_op);
+        ur->add_undo_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,graph->vec_scalar_op_node_get_op(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_rgb_op_changed(int p_op, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change RGB Operator");
-	ur->add_do_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,p_op);
-	ur->add_undo_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,graph->rgb_op_node_get_op(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change RGB Operator");
+        ur->add_do_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,p_op);
+        ur->add_undo_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,graph->rgb_op_node_get_op(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 void ShaderGraphView::_xform_inv_rev_changed(bool p_enabled, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Toggle Rot Only");
-	ur->add_do_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,p_enabled);
-	ur->add_undo_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,graph->xform_vec_mult_node_get_no_translation(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Toggle Rot Only");
+        ur->add_do_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,p_enabled);
+        ur->add_undo_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,graph->xform_vec_mult_node_get_no_translation(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 void ShaderGraphView::_scalar_func_changed(int p_func, int p_id){
 
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Scalar Function");
-	ur->add_do_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,p_func);
-	ur->add_undo_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,graph->scalar_func_node_get_function(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Scalar Function");
+        ur->add_do_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,p_func);
+        ur->add_undo_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,graph->scalar_func_node_get_function(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 void ShaderGraphView::_vec_func_changed(int p_func, int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Vec Function");
-	ur->add_do_method(graph.ptr(),"vec_func_node_set_function",type,p_id,p_func);
-	ur->add_undo_method(graph.ptr(),"vec_func_node_set_function",type,p_id,graph->vec_func_node_get_function(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Vec Function");
+        ur->add_do_method(graph.ptr(),"vec_func_node_set_function",type,p_id,p_func);
+        ur->add_undo_method(graph.ptr(),"vec_func_node_set_function",type,p_id,graph->vec_func_node_get_function(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_scalar_input_changed(double p_value,int p_id){
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Scalar Uniform",true);
-	ur->add_do_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,p_value);
-	ur->add_undo_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,graph->scalar_input_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Scalar Uniform",true);
+        ur->add_do_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,p_value);
+        ur->add_undo_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,graph->scalar_input_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_vec_input_changed(double p_value, int p_id,Array p_arr){
 
-	Vector3 val;
-	for(int i=0;i<p_arr.size();i++) {
-		val[i]=p_arr[i].call("get_val");
-	}
+        Vector3 val;
+        for(int i=0;i<p_arr.size();i++) {
+                val[i]=p_arr[i].call("get_val");
+        }
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Vec Uniform",true);
-	ur->add_do_method(graph.ptr(),"vec_input_node_set_value",type,p_id,val);
-	ur->add_undo_method(graph.ptr(),"vec_input_node_set_value",type,p_id,graph->vec_input_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Vec Uniform",true);
+        ur->add_do_method(graph.ptr(),"vec_input_node_set_value",type,p_id,val);
+        ur->add_undo_method(graph.ptr(),"vec_input_node_set_value",type,p_id,graph->vec_input_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 void ShaderGraphView::_xform_input_changed(int p_id, Node *p_button){
 
 
-	ToolButton *tb = p_button->cast_to<ToolButton>();
-	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-	ped_popup->set_size(tb->get_size());
-	edited_id=p_id;
-	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
-	ped_popup->popup();
+        ToolButton *tb = p_button->cast_to<ToolButton>();
+        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+        ped_popup->set_size(tb->get_size());
+        edited_id=p_id;
+        ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
+        ped_popup->popup();
 
 }
 void ShaderGraphView::_xform_const_changed(int p_id, Node *p_button){
 
-	ToolButton *tb = p_button->cast_to<ToolButton>();
-	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-	ped_popup->set_size(tb->get_size());
-	edited_id=p_id;
-	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
-	ped_popup->popup();
+        ToolButton *tb = p_button->cast_to<ToolButton>();
+        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+        ped_popup->set_size(tb->get_size());
+        edited_id=p_id;
+        ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
+        ped_popup->popup();
 
 }
 
 void ShaderGraphView::_rgb_input_changed(const Color& p_color, int p_id){
 
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change RGB Uniform",true);
-	ur->add_do_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,p_color);
-	ur->add_undo_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,graph->rgb_input_node_get_value(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change RGB Uniform",true);
+        ur->add_do_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,p_color);
+        ur->add_undo_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,graph->rgb_input_node_get_value(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 void ShaderGraphView::_tex_input_change(int p_id, Node *p_button){
 
@@ -879,180 +879,180 @@ void ShaderGraphView::_cube_input_change(int p_id){
 
 void ShaderGraphView::_variant_edited() {
 
-	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
+        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
 
-		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-		ur->create_action("Change XForm Uniform");
-		ur->add_do_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,ped_popup->get_variant());
-		ur->add_undo_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,graph->xform_const_node_get_value(type,edited_id));
-		ur->add_do_method(this,"_update_graph");
-		ur->add_undo_method(this,"_update_graph");
-		ur->commit_action();
-	}
+                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+                ur->create_action("Change XForm Uniform");
+                ur->add_do_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,ped_popup->get_variant());
+                ur->add_undo_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,graph->xform_const_node_get_value(type,edited_id));
+                ur->add_do_method(this,"_update_graph");
+                ur->add_undo_method(this,"_update_graph");
+                ur->commit_action();
+        }
 
 
-	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_INPUT) {
+        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_INPUT) {
 
-		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-		ur->create_action("Change XForm Uniform");
-		ur->add_do_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,ped_popup->get_variant());
-		ur->add_undo_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,graph->xform_input_node_get_value(type,edited_id));
-		ur->add_do_method(this,"_update_graph");
-		ur->add_undo_method(this,"_update_graph");
-		ur->commit_action();
-	}
+                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+                ur->create_action("Change XForm Uniform");
+                ur->add_do_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,ped_popup->get_variant());
+                ur->add_undo_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,graph->xform_input_node_get_value(type,edited_id));
+                ur->add_do_method(this,"_update_graph");
+                ur->add_undo_method(this,"_update_graph");
+                ur->commit_action();
+        }
 
-	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_TEXTURE_INPUT) {
+        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_TEXTURE_INPUT) {
 
-		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-		ur->create_action("Change Texture Uniform");
-		ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,ped_popup->get_variant());
-		ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,graph->texture_input_node_get_value(type,edited_id));
-		ur->add_do_method(this,"_update_graph");
-		ur->add_undo_method(this,"_update_graph");
-		ur->commit_action();
-	}
+                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+                ur->create_action("Change Texture Uniform");
+                ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,ped_popup->get_variant());
+                ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,graph->texture_input_node_get_value(type,edited_id));
+                ur->add_do_method(this,"_update_graph");
+                ur->add_undo_method(this,"_update_graph");
+                ur->commit_action();
+        }
 
-	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_CUBEMAP_INPUT) {
+        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_CUBEMAP_INPUT) {
 
-		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-		ur->create_action("Change Cubemap Uniform");
-		ur->add_do_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,ped_popup->get_variant());
-		ur->add_undo_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,graph->cubemap_input_node_get_value(type,edited_id));
-		ur->add_do_method(this,"_update_graph");
-		ur->add_undo_method(this,"_update_graph");
-		ur->commit_action();
-	}
+                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+                ur->create_action("Change Cubemap Uniform");
+                ur->add_do_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,ped_popup->get_variant());
+                ur->add_undo_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,graph->cubemap_input_node_get_value(type,edited_id));
+                ur->add_do_method(this,"_update_graph");
+                ur->add_undo_method(this,"_update_graph");
+                ur->commit_action();
+        }
 
 }
 
 void ShaderGraphView::_comment_edited(int p_id,Node* p_button) {
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	TextEdit *te=p_button->cast_to<TextEdit>();
-	ur->create_action("Change Comment",true);
-	ur->add_do_method(graph.ptr(),"comment_node_set_text",type,p_id,te->get_text());
-	ur->add_undo_method(graph.ptr(),"comment_node_set_text",type,p_id,graph->comment_node_get_text(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        TextEdit *te=p_button->cast_to<TextEdit>();
+        ur->create_action("Change Comment",true);
+        ur->add_do_method(graph.ptr(),"comment_node_set_text",type,p_id,te->get_text());
+        ur->add_undo_method(graph.ptr(),"comment_node_set_text",type,p_id,graph->comment_node_get_text(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 
 }
 
 void ShaderGraphView::_color_ramp_changed(int p_id,Node* p_ramp) {
 
-	GraphColorRampEdit *cr=p_ramp->cast_to<GraphColorRampEdit>();
+        GraphColorRampEdit *cr=p_ramp->cast_to<GraphColorRampEdit>();
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
 
-	Vector<float> offsets=cr->get_offsets();
-	Vector<Color> colors=cr->get_colors();
+        Vector<float> offsets=cr->get_offsets();
+        Vector<Color> colors=cr->get_colors();
 
-	DVector<float> new_offsets;
-	DVector<Color> new_colors;
-	{
-		new_offsets.resize(offsets.size());
-		new_colors.resize(colors.size());
-		DVector<float>::Write ow=new_offsets.write();
-		DVector<Color>::Write cw=new_colors.write();
-		for(int i=0;i<new_offsets.size();i++) {
-			ow[i]=offsets[i];
-			cw[i]=colors[i];
-		}
+        DVector<float> new_offsets;
+        DVector<Color> new_colors;
+        {
+                new_offsets.resize(offsets.size());
+                new_colors.resize(colors.size());
+                DVector<float>::Write ow=new_offsets.write();
+                DVector<Color>::Write cw=new_colors.write();
+                for(int i=0;i<new_offsets.size();i++) {
+                        ow[i]=offsets[i];
+                        cw[i]=colors[i];
+                }
 
-	}
+        }
 
 
-	DVector<float> old_offsets=graph->color_ramp_node_get_offsets(type,p_id);
-	DVector<Color> old_colors=graph->color_ramp_node_get_colors(type,p_id);
+        DVector<float> old_offsets=graph->color_ramp_node_get_offsets(type,p_id);
+        DVector<Color> old_colors=graph->color_ramp_node_get_colors(type,p_id);
 
-	if (old_offsets.size()!=new_offsets.size())
-		ur->create_action("Add/Remove to Color Ramp");
-	else
-		ur->create_action("Modify Color Ramp",true);
+        if (old_offsets.size()!=new_offsets.size())
+                ur->create_action("Add/Remove to Color Ramp");
+        else
+                ur->create_action("Modify Color Ramp",true);
 
-	ur->add_do_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,new_colors,new_offsets);
-	ur->add_undo_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,old_colors,old_offsets);
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        ur->add_do_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,new_colors,new_offsets);
+        ur->add_undo_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,old_colors,old_offsets);
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 
 void ShaderGraphView::_curve_changed(int p_id,Node* p_curve) {
 
-	GraphCurveMapEdit *cr=p_curve->cast_to<GraphCurveMapEdit>();
+        GraphCurveMapEdit *cr=p_curve->cast_to<GraphCurveMapEdit>();
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
 
-	Vector<Point2> points=cr->get_points();
+        Vector<Point2> points=cr->get_points();
 
-	DVector<Vector2> new_points;
-	{
-		new_points.resize(points.size());
-		DVector<Vector2>::Write ow=new_points.write();
-		for(int i=0;i<new_points.size();i++) {
-			ow[i]=points[i];
-		}
+        DVector<Vector2> new_points;
+        {
+                new_points.resize(points.size());
+                DVector<Vector2>::Write ow=new_points.write();
+                for(int i=0;i<new_points.size();i++) {
+                        ow[i]=points[i];
+                }
 
-	}
+        }
 
 
-	DVector<Vector2> old_points=graph->curve_map_node_get_points(type,p_id);
+        DVector<Vector2> old_points=graph->curve_map_node_get_points(type,p_id);
 
-	if (old_points.size()!=new_points.size())
-		ur->create_action("Add/Remove to Curve Map");
-	else
-		ur->create_action("Modify Curve Map",true);
+        if (old_points.size()!=new_points.size())
+                ur->create_action("Add/Remove to Curve Map");
+        else
+                ur->create_action("Modify Curve Map",true);
 
-	ur->add_do_method(graph.ptr(),"curve_map_node_set_points",type,p_id,new_points);
-	ur->add_undo_method(graph.ptr(),"curve_map_node_set_points",type,p_id,old_points);
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
+        ur->add_do_method(graph.ptr(),"curve_map_node_set_points",type,p_id,new_points);
+        ur->add_undo_method(graph.ptr(),"curve_map_node_set_points",type,p_id,old_points);
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
 }
 
 
 void ShaderGraphView::_input_name_changed(const String& p_name, int p_id, Node *p_line_edit) {
 
-	LineEdit *le=p_line_edit->cast_to<LineEdit>();
-	ERR_FAIL_COND(!le);
+        LineEdit *le=p_line_edit->cast_to<LineEdit>();
+        ERR_FAIL_COND(!le);
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Change Input Name");
-	ur->add_do_method(graph.ptr(),"input_node_set_name",type,p_id,p_name);
-	ur->add_undo_method(graph.ptr(),"input_node_set_name",type,p_id,graph->input_node_get_name(type,p_id));
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	block_update=true;
-	ur->commit_action();
-	block_update=false;
-	le->set_text(graph->input_node_get_name(type,p_id));
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Change Input Name");
+        ur->add_do_method(graph.ptr(),"input_node_set_name",type,p_id,p_name);
+        ur->add_undo_method(graph.ptr(),"input_node_set_name",type,p_id,graph->input_node_get_name(type,p_id));
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        block_update=true;
+        ur->commit_action();
+        block_update=false;
+        le->set_text(graph->input_node_get_name(type,p_id));
 }
 
 void ShaderGraphView::_tex_edited(int p_id,Node* p_button) {
 
-	ToolButton *tb = p_button->cast_to<ToolButton>();
-	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-	ped_popup->set_size(tb->get_size());
-	edited_id=p_id;
-	ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
+        ToolButton *tb = p_button->cast_to<ToolButton>();
+        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+        ped_popup->set_size(tb->get_size());
+        edited_id=p_id;
+        ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
 }
 
 void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
 
-	ToolButton *tb = p_button->cast_to<ToolButton>();
-	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-	ped_popup->set_size(tb->get_size());
-	edited_id=p_id;
-	ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
+        ToolButton *tb = p_button->cast_to<ToolButton>();
+        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+        ped_popup->set_size(tb->get_size());
+        edited_id=p_id;
+        ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
 }
 
 
@@ -1061,983 +1061,994 @@ void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
 
 void ShaderGraphView::_connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
-	int from_idx=-1;
-	int to_idx=-1;
-	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+        int from_idx=-1;
+        int to_idx=-1;
+        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-		if (p_from==E->get()->get_name())
-			from_idx=E->key();
-		if (p_to==E->get()->get_name())
-			to_idx=E->key();
-	}
+                if (p_from==E->get()->get_name())
+                        from_idx=E->key();
+                if (p_to==E->get()->get_name())
+                        to_idx=E->key();
+        }
 
-	ERR_FAIL_COND(from_idx==-1);
-	ERR_FAIL_COND(to_idx==-1);
+        ERR_FAIL_COND(from_idx==-1);
+        ERR_FAIL_COND(to_idx==-1);
 
-	ur->create_action("Connect Graph Nodes");
+        ur->create_action("Connect Graph Nodes");
 
-	List<ShaderGraph::Connection> conns;
+        List<ShaderGraph::Connection> conns;
 
-	graph->get_node_connections(type,&conns);
-	//disconnect/reconnect dependencies
-	ur->add_undo_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-	for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
+        graph->get_node_connections(type,&conns);
+        //disconnect/reconnect dependencies
+        ur->add_undo_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+        for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
 
-		if (E->get().dst_id==to_idx && E->get().dst_slot==p_to_slot) {
-			ur->add_do_method(graph.ptr(),"disconnect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-			ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-		}
-	}
-	ur->add_do_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	ur->commit_action();
+                if (E->get().dst_id==to_idx && E->get().dst_slot==p_to_slot) {
+                        ur->add_do_method(graph.ptr(),"disconnect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+                        ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+                }
+        }
+        ur->add_do_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        ur->commit_action();
 
 
 }
 
 void ShaderGraphView::_disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
-	int from_idx=-1;
-	int to_idx=-1;
-	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+        int from_idx=-1;
+        int to_idx=-1;
+        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-		if (p_from==E->get()->get_name())
-			from_idx=E->key();
-		if (p_to==E->get()->get_name())
-			to_idx=E->key();
-	}
+                if (p_from==E->get()->get_name())
+                        from_idx=E->key();
+                if (p_to==E->get()->get_name())
+                        to_idx=E->key();
+        }
 
-	ERR_FAIL_COND(from_idx==-1);
-	ERR_FAIL_COND(to_idx==-1);
+        ERR_FAIL_COND(from_idx==-1);
+        ERR_FAIL_COND(to_idx==-1);
 
-	if (!graph->is_node_connected(type,from_idx,p_from_slot,to_idx,p_to_slot))
-		return; //nothing to disconnect
+        if (!graph->is_node_connected(type,from_idx,p_from_slot,to_idx,p_to_slot))
+                return; //nothing to disconnect
 
-	ur->create_action("Disconnect Graph Nodes");
+        ur->create_action("Disconnect Graph Nodes");
 
-	List<ShaderGraph::Connection> conns;
+        List<ShaderGraph::Connection> conns;
 
-	graph->get_node_connections(type,&conns);
-	//disconnect/reconnect dependencies
-	ur->add_do_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-	ur->add_undo_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	ur->commit_action();
+        graph->get_node_connections(type,&conns);
+        //disconnect/reconnect dependencies
+        ur->add_do_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+        ur->add_undo_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        ur->commit_action();
 
 
 }
 
 void ShaderGraphView::_node_removed(int p_id) {
 
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Remove Shader Graph Node");
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Remove Shader Graph Node");
 
-	ur->add_do_method(graph.ptr(),"node_remove",type,p_id);
-	ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,p_id),p_id);
-	ur->add_undo_method(graph.ptr(),"node_set_state",type,p_id,graph->node_get_state(type,p_id));
-	List<ShaderGraph::Connection> conns;
+        ur->add_do_method(graph.ptr(),"node_remove",type,p_id);
+        ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,p_id),p_id);
+        ur->add_undo_method(graph.ptr(),"node_set_state",type,p_id,graph->node_get_state(type,p_id));
+        List<ShaderGraph::Connection> conns;
 
-	graph->get_node_connections(type,&conns);
-	for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
+        graph->get_node_connections(type,&conns);
+        for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
 
-		if (E->get().dst_id==p_id || E->get().src_id==p_id) {
-			ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-		}
-	}
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	ur->commit_action();
+                if (E->get().dst_id==p_id || E->get().src_id==p_id) {
+                        ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+                }
+        }
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        ur->commit_action();
 
 }
 
+void ShaderGraphView::_begin_node_move()
+{
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Move Shader Graph Node");
+}
+
 void ShaderGraphView::_node_moved(const Vector2& p_from, const Vector2& p_to,int p_id) {
 
 
-	ERR_FAIL_COND(!node_map.has(p_id));
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Move Shader Graph Node");
-	ur->add_do_method(this,"_move_node",p_id,p_to);
-	ur->add_undo_method(this,"_move_node",p_id,p_from);
-	ur->commit_action();
+        ERR_FAIL_COND(!node_map.has(p_id));
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->add_do_method(this,"_move_node",p_id,p_to);
+        ur->add_undo_method(this,"_move_node",p_id,p_from);
+}
+
+void ShaderGraphView::_end_node_move()
+{
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->commit_action();
 }
 
 void ShaderGraphView::_move_node(int p_id,const Vector2& p_to) {
 
-	ERR_FAIL_COND(!node_map.has(p_id));
-	node_map[p_id]->set_offset(p_to);
-	graph->node_set_pos(type,p_id,p_to);
+        ERR_FAIL_COND(!node_map.has(p_id));
+        node_map[p_id]->set_offset(p_to);
+        graph->node_set_pos(type,p_id,p_to);
 }
 
 
 void ShaderGraphView::_create_node(int p_id) {
 
 
-	GraphNode *gn = memnew( GraphNode );
-	gn->set_show_close_button(true);
-	Color typecol[4]={
-		Color(0.9,0.4,1),
-		Color(0.8,1,0.2),
-		Color(1,0.2,0.2),
-		Color(0,1,1)
-	};
-
-
-	switch(graph->node_get_type(type,p_id)) {
-
-		case ShaderGraph::NODE_INPUT: {
-
-			gn->set_title("Input");
-
-			List<ShaderGraph::SlotInfo> si;
-			ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
-
-			int idx=0;
-			for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
-				ShaderGraph::SlotInfo& s=E->get();
-				if (s.dir==ShaderGraph::SLOT_IN) {
-
-					Label *l= memnew( Label );
-					l->set_text(s.name);
-					l->set_align(Label::ALIGN_RIGHT);
-					gn->add_child(l);
-					gn->set_slot(idx,false,0,Color(),true,s.type,typecol[s.type]);
-					idx++;
-				}
-			}
-
-		} break; // all inputs (case Shader type dependent)
-		case ShaderGraph::NODE_SCALAR_CONST: {
-			gn->set_title("Scalar");
-			SpinBox *sb = memnew( SpinBox );
-			sb->set_min(-100000);
-			sb->set_max(100000);
-			sb->set_step(0.001);
-			sb->set_val(graph->scalar_const_node_get_value(type,p_id));
-			sb->connect("value_changed",this,"_scalar_const_changed",varray(p_id));
-			gn->add_child(sb);
-			gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; //scalar constant
-		case ShaderGraph::NODE_VEC_CONST: {
-
-			gn->set_title("Vector");
-			Array v3p(true);
-			for(int i=0;i<3;i++) {
-				HBoxContainer *hbc = memnew( HBoxContainer );
-				Label *l = memnew( Label );
-				l->set_text(String::chr('X'+i));
-				hbc->add_child(l);
-				SpinBox *sb = memnew( SpinBox );
-				sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
-				sb->set_min(-100000);
-				sb->set_max(100000);
-				sb->set_step(0.001);
-				sb->set_val(graph->vec_const_node_get_value(type,p_id)[i]);
-				sb->connect("value_changed",this,"_vec_const_changed",varray(p_id,v3p));
-				v3p.push_back(sb);
-				hbc->add_child(sb);
-				gn->add_child(hbc);
-			}
-			gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-		} break; //vec3 constant
-		case ShaderGraph::NODE_RGB_CONST: {
-
-			gn->set_title("Color");
-			ColorPickerButton *cpb = memnew( ColorPickerButton );
-			cpb->set_color(graph->rgb_const_node_get_value(type,p_id));
-			cpb->connect("color_changed",this,"_rgb_const_changed",varray(p_id));
-			gn->add_child(cpb);
-			Label *l = memnew( Label );
-			l->set_text("RGB");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-			l = memnew( Label );
-			l->set_text("Alpha");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; //rgb constant (shows a color picker instead)
-		case ShaderGraph::NODE_XFORM_CONST: {
-			gn->set_title("XForm");
-			ToolButton *edit = memnew( ToolButton );
-			edit->set_text("edit..");
-			edit->connect("pressed",this,"_xform_const_changed",varray(p_id,edit));
-			gn->add_child(edit);
-			gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-
-		} break; // 4x4 matrix constant
-		case ShaderGraph::NODE_TIME: {
-
-			gn->set_title("Time");
-			Label *l = memnew( Label );
-			l->set_text("(s)");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-			gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; // time in seconds
-		case ShaderGraph::NODE_SCREEN_TEX: {
-
-			gn->set_title("ScreenTex");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("UV")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("RGB")));
-			gn->add_child(hbc);
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-		} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
-		case ShaderGraph::NODE_SCALAR_OP: {
-
-			gn->set_title("ScalarOp");
-			static const char* op_name[ShaderGraph::SCALAR_MAX_OP]={
-				"Add",
-				"Sub",
-				"Mul",
-				"Div",
-				"Mod",
-				"Pow",
-				"Max",
-				"Min",
-				"Atan2"
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::SCALAR_MAX_OP;i++) {
-
-				ob->add_item(op_name[i],i);
-			}
-
-			ob->select(graph->scalar_op_node_get_op(type,p_id));
-			ob->connect("item_selected",this,"_scalar_op_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-		} break; // scalar vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
-		case ShaderGraph::NODE_VEC_OP: {
-
-			gn->set_title("VecOp");
-			static const char* op_name[ShaderGraph::VEC_MAX_OP]={
-				"Add",
-				"Sub",
-				"Mul",
-				"Div",
-				"Mod",
-				"Pow",
-				"Max",
-				"Min",
-				"Cross"
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::VEC_MAX_OP;i++) {
-
-				ob->add_item(op_name[i],i);
-			}
-
-			ob->select(graph->vec_op_node_get_op(type,p_id));
-			ob->connect("item_selected",this,"_vec_op_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-
-		} break; // vec3 vs vec3 op (mul: { } break;ad: { } break;div: { } break;crossprod: { } break;etc)
-		case ShaderGraph::NODE_VEC_SCALAR_OP: {
-
-			gn->set_title("VecScalarOp");
-			static const char* op_name[ShaderGraph::VEC_SCALAR_MAX_OP]={
-				"Mul",
-				"Div",
-				"Pow",
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::VEC_SCALAR_MAX_OP;i++) {
-
-				ob->add_item(op_name[i],i);
-			}
-
-			ob->select(graph->vec_scalar_op_node_get_op(type,p_id));
-			ob->connect("item_selected",this,"_vec_scalar_op_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-		} break; // vec3 vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
-		case ShaderGraph::NODE_RGB_OP: {
-
-			gn->set_title("RGB Op");
-			static const char* op_name[ShaderGraph::RGB_MAX_OP]={
-				"Screen",
-				"Difference",
-				"Darken",
-				"Lighten",
-				"Overlay",
-				"Dodge",
-				"Burn",
-				"SoftLight",
-				"HardLight"
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::RGB_MAX_OP;i++) {
-
-				ob->add_item(op_name[i],i);
-			}
-
-			ob->select(graph->rgb_op_node_get_op(type,p_id));
-			ob->connect("item_selected",this,"_rgb_op_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-		} break; // vec3 vs vec3 rgb op (with scalar amount): { } break; like brighten: { } break; darken: { } break; burn: { } break; dodge: { } break; multiply: { } break; etc.
-		case ShaderGraph::NODE_XFORM_MULT: {
-
-			gn->set_title("XFMult");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
-
-
-		} break; // mat4 x mat4
-		case ShaderGraph::NODE_XFORM_VEC_MULT: {
-
-			gn->set_title("XFVecMult");
-
-			Button *button = memnew( Button("RotOnly"));
-			button->set_toggle_mode(true);
-			button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
-			button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
-
-			gn->add_child(button);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("xf")));
-			hbc->add_spacer();
-			Label *l = memnew(Label("out"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("vec")));
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-		} break;
-		case ShaderGraph::NODE_XFORM_VEC_INV_MULT: {
-
-			gn->set_title("XFVecInvMult");
-
-
-			Button *button = memnew( Button("RotOnly"));
-			button->set_toggle_mode(true);
-			button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
-			button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
-
-			gn->add_child(button);
-
-			gn->add_child( memnew(Label("vec")));
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("xf")));
-			hbc->add_spacer();
-			Label *l = memnew(Label("out"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-
-		} break; // mat4 x vec3 inverse mult (with no-translation option)
-		case ShaderGraph::NODE_SCALAR_FUNC: {
-
-			gn->set_title("ScalarFunc");
-			static const char* func_name[ShaderGraph::SCALAR_MAX_FUNC]={
-				"Sin",
-				"Cos",
-				"Tan",
-				"ASin",
-				"ACos",
-				"ATan",
-				"SinH",
-				"CosH",
-				"TanH",
-				"Log",
-				"Exp",
-				"Sqrt",
-				"Abs",
-				"Sign",
-				"Floor",
-				"Round",
-				"Ceil",
-				"Frac",
-				"Satr",
-				"Neg"
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::SCALAR_MAX_FUNC;i++) {
-
-				ob->add_item(func_name[i],i);
-			}
-
-			ob->select(graph->scalar_func_node_get_function(type,p_id));
-			ob->connect("item_selected",this,"_scalar_func_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_child( memnew(Label("in")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-		} break; // scalar function (sin: { } break; cos: { } break; etc)
-		case ShaderGraph::NODE_VEC_FUNC: {
-
-
-
-			gn->set_title("VecFunc");
-			static const char* func_name[ShaderGraph::VEC_MAX_FUNC]={
-				"Normalize",
-				"Saturate",
-				"Negate",
-				"Reciprocal",
-				"RGB to HSV",
-				"HSV to RGB",
-			};
-
-			OptionButton *ob = memnew( OptionButton );
-			for(int i=0;i<ShaderGraph::VEC_MAX_FUNC;i++) {
-
-				ob->add_item(func_name[i],i);
-			}
-
-			ob->select(graph->vec_func_node_get_function(type,p_id));
-			ob->connect("item_selected",this,"_vec_func_changed",varray(p_id));
-			gn->add_child(ob);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("in")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("out")));
-			gn->add_child(hbc);
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-		} break; // vector function (normalize: { } break; negate: { } break; reciprocal: { } break; rgb2hsv: { } break; hsv2rgb: { } break; etc: { } break; etc)
-		case ShaderGraph::NODE_VEC_LEN: {
-			gn->set_title("VecLength");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_child( memnew(Label("in")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("len")));
-			gn->add_child(hbc);
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; // vec3 length
-		case ShaderGraph::NODE_DOT_PROD: {
-
-			gn->set_title("DotProduct");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("dp")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-		} break; // vec3 . vec3 (dot product -> scalar output)
-		case ShaderGraph::NODE_VEC_TO_SCALAR: {
-
-			gn->set_title("Vec2Scalar");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("vec")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("x"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-			l=memnew(Label("y"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l );
-			l=memnew(Label("z"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l);
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-			gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-
-
-		} break; // 1 vec3 input: { } break; 3 scalar outputs
-		case ShaderGraph::NODE_SCALAR_TO_VEC: {
-
-			gn->set_title("Scalar2Vec");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_child( memnew(Label("x")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("vec")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("y")));
-			gn->add_child( memnew(Label("z")));
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-		} break; // 3 scalar input: { } break; 1 vec3 output
-		case ShaderGraph::NODE_VEC_TO_XFORM: {
-
-			gn->set_title("Vec2XForm");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("x")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("xf")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("y")));
-			gn->add_child( memnew(Label("z")));
-			gn->add_child( memnew(Label("ofs")));
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-			gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-		} break; // 3 vec input: { } break; 1 xform output
-		case ShaderGraph::NODE_XFORM_TO_VEC: {
-
-			gn->set_title("XForm2Vec");
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("xf")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("x"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-			l=memnew(Label("y"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l );
-			l=memnew(Label("z"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l);
-			l=memnew(Label("ofs"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l);
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-		} break; // 3 vec input: { } break; 1 xform output
-		case ShaderGraph::NODE_SCALAR_INTERP: {
-
-			gn->set_title("ScalarInterp");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("interp")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-			gn->add_child( memnew(Label("c")));
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-		} break; // scalar interpolation (with optional curve)
-		case ShaderGraph::NODE_VEC_INTERP: {
-
-			gn->set_title("VecInterp");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_child( memnew(Label("a")));
-			hbc->add_spacer();
-			hbc->add_child( memnew(Label("interp")));
-			gn->add_child(hbc);
-			gn->add_child( memnew(Label("b")));
-			gn->add_child( memnew(Label("c")));
+        GraphNode *gn = memnew( GraphNode );
+        gn->set_show_close_button(true);
+        Color typecol[4]={
+                Color(0.9,0.4,1),
+                Color(0.8,1,0.2),
+                Color(1,0.2,0.2),
+                Color(0,1,1)
+        };
+
+
+        switch(graph->node_get_type(type,p_id)) {
+
+                case ShaderGraph::NODE_INPUT: {
+
+                        gn->set_title("Input");
+
+                        List<ShaderGraph::SlotInfo> si;
+                        ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
+
+                        int idx=0;
+                        for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
+                                ShaderGraph::SlotInfo& s=E->get();
+                                if (s.dir==ShaderGraph::SLOT_IN) {
+
+                                        Label *l= memnew( Label );
+                                        l->set_text(s.name);
+                                        l->set_align(Label::ALIGN_RIGHT);
+                                        gn->add_child(l);
+                                        gn->set_slot(idx,false,0,Color(),true,s.type,typecol[s.type]);
+                                        idx++;
+                                }
+                        }
+
+                } break; // all inputs (case Shader type dependent)
+                case ShaderGraph::NODE_SCALAR_CONST: {
+                        gn->set_title("Scalar");
+                        SpinBox *sb = memnew( SpinBox );
+                        sb->set_min(-100000);
+                        sb->set_max(100000);
+                        sb->set_step(0.001);
+                        sb->set_val(graph->scalar_const_node_get_value(type,p_id));
+                        sb->connect("value_changed",this,"_scalar_const_changed",varray(p_id));
+                        gn->add_child(sb);
+                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; //scalar constant
+                case ShaderGraph::NODE_VEC_CONST: {
+
+                        gn->set_title("Vector");
+                        Array v3p(true);
+                        for(int i=0;i<3;i++) {
+                                HBoxContainer *hbc = memnew( HBoxContainer );
+                                Label *l = memnew( Label );
+                                l->set_text(String::chr('X'+i));
+                                hbc->add_child(l);
+                                SpinBox *sb = memnew( SpinBox );
+                                sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
+                                sb->set_min(-100000);
+                                sb->set_max(100000);
+                                sb->set_step(0.001);
+                                sb->set_val(graph->vec_const_node_get_value(type,p_id)[i]);
+                                sb->connect("value_changed",this,"_vec_const_changed",varray(p_id,v3p));
+                                v3p.push_back(sb);
+                                hbc->add_child(sb);
+                                gn->add_child(hbc);
+                        }
+                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+                } break; //vec3 constant
+                case ShaderGraph::NODE_RGB_CONST: {
+
+                        gn->set_title("Color");
+                        ColorPickerButton *cpb = memnew( ColorPickerButton );
+                        cpb->set_color(graph->rgb_const_node_get_value(type,p_id));
+                        cpb->connect("color_changed",this,"_rgb_const_changed",varray(p_id));
+                        gn->add_child(cpb);
+                        Label *l = memnew( Label );
+                        l->set_text("RGB");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+                        l = memnew( Label );
+                        l->set_text("Alpha");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; //rgb constant (shows a color picker instead)
+                case ShaderGraph::NODE_XFORM_CONST: {
+                        gn->set_title("XForm");
+                        ToolButton *edit = memnew( ToolButton );
+                        edit->set_text("edit..");
+                        edit->connect("pressed",this,"_xform_const_changed",varray(p_id,edit));
+                        gn->add_child(edit);
+                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+
+                } break; // 4x4 matrix constant
+                case ShaderGraph::NODE_TIME: {
+
+                        gn->set_title("Time");
+                        Label *l = memnew( Label );
+                        l->set_text("(s)");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; // time in seconds
+                case ShaderGraph::NODE_SCREEN_TEX: {
+
+                        gn->set_title("ScreenTex");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("UV")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("RGB")));
+                        gn->add_child(hbc);
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+                } break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
+                case ShaderGraph::NODE_SCALAR_OP: {
+
+                        gn->set_title("ScalarOp");
+                        static const char* op_name[ShaderGraph::SCALAR_MAX_OP]={
+                                "Add",
+                                "Sub",
+                                "Mul",
+                                "Div",
+                                "Mod",
+                                "Pow",
+                                "Max",
+                                "Min",
+                                "Atan2"
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::SCALAR_MAX_OP;i++) {
+
+                                ob->add_item(op_name[i],i);
+                        }
+
+                        ob->select(graph->scalar_op_node_get_op(type,p_id));
+                        ob->connect("item_selected",this,"_scalar_op_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+                } break; // scalar vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
+                case ShaderGraph::NODE_VEC_OP: {
+
+                        gn->set_title("VecOp");
+                        static const char* op_name[ShaderGraph::VEC_MAX_OP]={
+                                "Add",
+                                "Sub",
+                                "Mul",
+                                "Div",
+                                "Mod",
+                                "Pow",
+                                "Max",
+                                "Min",
+                                "Cross"
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::VEC_MAX_OP;i++) {
+
+                                ob->add_item(op_name[i],i);
+                        }
+
+                        ob->select(graph->vec_op_node_get_op(type,p_id));
+                        ob->connect("item_selected",this,"_vec_op_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+
+                } break; // vec3 vs vec3 op (mul: { } break;ad: { } break;div: { } break;crossprod: { } break;etc)
+                case ShaderGraph::NODE_VEC_SCALAR_OP: {
+
+                        gn->set_title("VecScalarOp");
+                        static const char* op_name[ShaderGraph::VEC_SCALAR_MAX_OP]={
+                                "Mul",
+                                "Div",
+                                "Pow",
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::VEC_SCALAR_MAX_OP;i++) {
+
+                                ob->add_item(op_name[i],i);
+                        }
+
+                        ob->select(graph->vec_scalar_op_node_get_op(type,p_id));
+                        ob->connect("item_selected",this,"_vec_scalar_op_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+                } break; // vec3 vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
+                case ShaderGraph::NODE_RGB_OP: {
+
+                        gn->set_title("RGB Op");
+                        static const char* op_name[ShaderGraph::RGB_MAX_OP]={
+                                "Screen",
+                                "Difference",
+                                "Darken",
+                                "Lighten",
+                                "Overlay",
+                                "Dodge",
+                                "Burn",
+                                "SoftLight",
+                                "HardLight"
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::RGB_MAX_OP;i++) {
+
+                                ob->add_item(op_name[i],i);
+                        }
+
+                        ob->select(graph->rgb_op_node_get_op(type,p_id));
+                        ob->connect("item_selected",this,"_rgb_op_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+                } break; // vec3 vs vec3 rgb op (with scalar amount): { } break; like brighten: { } break; darken: { } break; burn: { } break; dodge: { } break; multiply: { } break; etc.
+                case ShaderGraph::NODE_XFORM_MULT: {
+
+                        gn->set_title("XFMult");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
+
+
+                } break; // mat4 x mat4
+                case ShaderGraph::NODE_XFORM_VEC_MULT: {
+
+                        gn->set_title("XFVecMult");
+
+                        Button *button = memnew( Button("RotOnly"));
+                        button->set_toggle_mode(true);
+                        button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
+                        button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
+
+                        gn->add_child(button);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("xf")));
+                        hbc->add_spacer();
+                        Label *l = memnew(Label("out"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("vec")));
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+                } break;
+                case ShaderGraph::NODE_XFORM_VEC_INV_MULT: {
+
+                        gn->set_title("XFVecInvMult");
+
+
+                        Button *button = memnew( Button("RotOnly"));
+                        button->set_toggle_mode(true);
+                        button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
+                        button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
+
+                        gn->add_child(button);
+
+                        gn->add_child( memnew(Label("vec")));
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("xf")));
+                        hbc->add_spacer();
+                        Label *l = memnew(Label("out"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+
+                } break; // mat4 x vec3 inverse mult (with no-translation option)
+                case ShaderGraph::NODE_SCALAR_FUNC: {
+
+                        gn->set_title("ScalarFunc");
+                        static const char* func_name[ShaderGraph::SCALAR_MAX_FUNC]={
+                                "Sin",
+                                "Cos",
+                                "Tan",
+                                "ASin",
+                                "ACos",
+                                "ATan",
+                                "SinH",
+                                "CosH",
+                                "TanH",
+                                "Log",
+                                "Exp",
+                                "Sqrt",
+                                "Abs",
+                                "Sign",
+                                "Floor",
+                                "Round",
+                                "Ceil",
+                                "Frac",
+                                "Satr",
+                                "Neg"
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::SCALAR_MAX_FUNC;i++) {
+
+                                ob->add_item(func_name[i],i);
+                        }
+
+                        ob->select(graph->scalar_func_node_get_function(type,p_id));
+                        ob->connect("item_selected",this,"_scalar_func_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_child( memnew(Label("in")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+                } break; // scalar function (sin: { } break; cos: { } break; etc)
+                case ShaderGraph::NODE_VEC_FUNC: {
+
+
+
+                        gn->set_title("VecFunc");
+                        static const char* func_name[ShaderGraph::VEC_MAX_FUNC]={
+                                "Normalize",
+                                "Saturate",
+                                "Negate",
+                                "Reciprocal",
+                                "RGB to HSV",
+                                "HSV to RGB",
+                        };
+
+                        OptionButton *ob = memnew( OptionButton );
+                        for(int i=0;i<ShaderGraph::VEC_MAX_FUNC;i++) {
+
+                                ob->add_item(func_name[i],i);
+                        }
+
+                        ob->select(graph->vec_func_node_get_function(type,p_id));
+                        ob->connect("item_selected",this,"_vec_func_changed",varray(p_id));
+                        gn->add_child(ob);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("in")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("out")));
+                        gn->add_child(hbc);
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+                } break; // vector function (normalize: { } break; negate: { } break; reciprocal: { } break; rgb2hsv: { } break; hsv2rgb: { } break; etc: { } break; etc)
+                case ShaderGraph::NODE_VEC_LEN: {
+                        gn->set_title("VecLength");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_child( memnew(Label("in")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("len")));
+                        gn->add_child(hbc);
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; // vec3 length
+                case ShaderGraph::NODE_DOT_PROD: {
+
+                        gn->set_title("DotProduct");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("dp")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+                } break; // vec3 . vec3 (dot product -> scalar output)
+                case ShaderGraph::NODE_VEC_TO_SCALAR: {
+
+                        gn->set_title("Vec2Scalar");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("vec")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("x"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+                        l=memnew(Label("y"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l );
+                        l=memnew(Label("z"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l);
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+
+
+                } break; // 1 vec3 input: { } break; 3 scalar outputs
+                case ShaderGraph::NODE_SCALAR_TO_VEC: {
+
+                        gn->set_title("Scalar2Vec");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_child( memnew(Label("x")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("vec")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("y")));
+                        gn->add_child( memnew(Label("z")));
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+                } break; // 3 scalar input: { } break; 1 vec3 output
+                case ShaderGraph::NODE_VEC_TO_XFORM: {
+
+                        gn->set_title("Vec2XForm");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("x")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("xf")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("y")));
+                        gn->add_child( memnew(Label("z")));
+                        gn->add_child( memnew(Label("ofs")));
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+                        gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+                } break; // 3 vec input: { } break; 1 xform output
+                case ShaderGraph::NODE_XFORM_TO_VEC: {
+
+                        gn->set_title("XForm2Vec");
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("xf")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("x"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+                        l=memnew(Label("y"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l );
+                        l=memnew(Label("z"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l);
+                        l=memnew(Label("ofs"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l);
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+                } break; // 3 vec input: { } break; 1 xform output
+                case ShaderGraph::NODE_SCALAR_INTERP: {
+
+                        gn->set_title("ScalarInterp");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("interp")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+                        gn->add_child( memnew(Label("c")));
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+                } break; // scalar interpolation (with optional curve)
+                case ShaderGraph::NODE_VEC_INTERP: {
+
+                        gn->set_title("VecInterp");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_child( memnew(Label("a")));
+                        hbc->add_spacer();
+                        hbc->add_child( memnew(Label("interp")));
+                        gn->add_child(hbc);
+                        gn->add_child( memnew(Label("b")));
+                        gn->add_child( memnew(Label("c")));
 
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
 
-		} break; // vec3 interpolation  (with optional curve)
-		case ShaderGraph::NODE_COLOR_RAMP: {
-
-			gn->set_title("ColorRamp");
-			GraphColorRampEdit * ramp  = memnew( GraphColorRampEdit );
-
-			DVector<real_t> offsets = graph->color_ramp_node_get_offsets(type,p_id);
-			DVector<Color> colors = graph->color_ramp_node_get_colors(type,p_id);
-
-			int oc = offsets.size();
-
-			if (oc) {
-				DVector<real_t>::Read rofs = offsets.read();
-				DVector<Color>::Read rcol = colors.read();
-
-				Vector<float> ofsv;
-				Vector<Color> colorv;
-				for(int i=0;i<oc;i++) {
-					ofsv.push_back(rofs[i]);
-					colorv.push_back(rcol[i]);
-				}
-
-				ramp->set_ramp(ofsv,colorv);
-
-			}
-
-			ramp->connect("ramp_changed",this,"_color_ramp_changed",varray(p_id,ramp));
-			ramp->set_custom_minimum_size(Size2(128,1));
-			gn->add_child(ramp);
-
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("c")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("rgb"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-			l=memnew(Label("alpha"));
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child( l);
-
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(2,false,ShaderGraph::SLOT_MAX,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-		} break; // scalar interpolation (with optional curve)
-		case ShaderGraph::NODE_CURVE_MAP: {
-
-			gn->set_title("CurveMap");
-			GraphCurveMapEdit * map  = memnew( GraphCurveMapEdit );
-
-			DVector<Vector2> points = graph->curve_map_node_get_points(type,p_id);
-
-			int oc = points.size();
-
-			if (oc) {
-				DVector<Vector2>::Read rofs = points.read();
-
-
-				Vector<Vector2> ofsv;
-				for(int i=0;i<oc;i++) {
-					ofsv.push_back(rofs[i]);
-				}
-
-				map->set_points(ofsv);
-
-			}
-			map->connect("curve_changed",this,"_curve_changed",varray(p_id,map));
-
-			//map->connect("map_changed",this,"_curve_map_changed",varray(p_id,map));
-			map->set_custom_minimum_size(Size2(128,64));
-			gn->add_child(map);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("c")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("cmap"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child( l);
-			gn->add_child(hbc);
-
-
-			gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-		} break; // scalar interpolation (with optional curve)
-
-		case ShaderGraph::NODE_SCALAR_INPUT: {
-
-			gn->set_title("ScalarUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-			SpinBox *sb = memnew( SpinBox );
-			sb->set_min(-100000);
-			sb->set_max(100000);
-			sb->set_step(0.001);
-			sb->set_val(graph->scalar_input_node_get_value(type,p_id));
-			sb->connect("value_changed",this,"_scalar_input_changed",varray(p_id));
-			gn->add_child(sb);
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; // scalar uniform (assignable in material)
-		case ShaderGraph::NODE_VEC_INPUT: {
-
-			gn->set_title("VectorUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-			Array v3p(true);
-			for(int i=0;i<3;i++) {
-				HBoxContainer *hbc = memnew( HBoxContainer );
-				Label *l = memnew( Label );
-				l->set_text(String::chr('X'+i));
-				hbc->add_child(l);
-				SpinBox *sb = memnew( SpinBox );
-				sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
-				sb->set_min(-100000);
-				sb->set_max(100000);
-				sb->set_step(0.001);
-				sb->set_val(graph->vec_input_node_get_value(type,p_id)[i]);
-				sb->connect("value_changed",this,"_vec_input_changed",varray(p_id,v3p));
-				v3p.push_back(sb);
-				hbc->add_child(sb);
-				gn->add_child(hbc);
-			}
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-		} break; // vec3 uniform (assignable in material)
-		case ShaderGraph::NODE_RGB_INPUT: {
-
-			gn->set_title("ColorUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-			ColorPickerButton *cpb = memnew( ColorPickerButton );
-			cpb->set_color(graph->rgb_input_node_get_value(type,p_id));
-			cpb->connect("color_changed",this,"_rgb_input_changed",varray(p_id));
-			gn->add_child(cpb);
-			Label *l = memnew( Label );
-			l->set_text("RGB");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-			l = memnew( Label );
-			l->set_text("Alpha");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-
-			gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-		} break; // color uniform (assignable in material)
-		case ShaderGraph::NODE_XFORM_INPUT: {
-			gn->set_title("XFUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-			ToolButton *edit = memnew( ToolButton );
-			edit->set_text("edit..");
-			edit->connect("pressed",this,"_xform_input_changed",varray(p_id,edit));
-			gn->add_child(edit);
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-
-		} break; // mat4 uniform (assignable in material)
-		case ShaderGraph::NODE_TEXTURE_INPUT: {
-
-			gn->set_title("TexUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-			TextureFrame *tex = memnew( TextureFrame );
-			tex->set_expand(true);
-			tex->set_custom_minimum_size(Size2(80,80));
-			gn->add_child(tex);
-			tex->set_texture(graph->texture_input_node_get_value(type,p_id));
-			ToolButton *edit = memnew( ToolButton );
-			edit->set_text("edit..");
-			edit->connect("pressed",this,"_tex_edited",varray(p_id,edit));
-			gn->add_child(edit);
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("UV")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("RGB"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child(l);
-			gn->add_child(hbc);
-			l = memnew( Label );
-			l->set_text("Alpha");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-
-			gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(4,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; // texture input (assignable in material)
-		case ShaderGraph::NODE_CUBEMAP_INPUT: {
-
-			gn->set_title("TexUniform");
-			LineEdit *le = memnew( LineEdit );
-			gn->add_child(le);
-			le->set_text(graph->input_node_get_name(type,p_id));
-			le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-
-			ToolButton *edit = memnew( ToolButton );
-			edit->set_text("edit..");
-			edit->connect("pressed",this,"_cube_edited",varray(p_id,edit));
-			gn->add_child(edit);
-
-
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("UV")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("RGB"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child(l);
-			gn->add_child(hbc);
-			l = memnew( Label );
-			l->set_text("Alpha");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-
-			gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-		} break; // cubemap input (assignable in material)
-		case ShaderGraph::NODE_DEFAULT_TEXTURE: {
-
-			gn->set_title("CanvasItemTex");
-			HBoxContainer *hbc = memnew( HBoxContainer );
-			hbc->add_constant_override("separation",0);
-			hbc->add_child( memnew(Label("UV")));
-			hbc->add_spacer();
-			Label *l=memnew(Label("RGB"));
-			l->set_align(Label::ALIGN_RIGHT);
-			hbc->add_child(l);
-			gn->add_child(hbc);
-			l = memnew( Label );
-			l->set_text("Alpha");
-			l->set_align(Label::ALIGN_RIGHT);
-			gn->add_child(l);
-
-			gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-			gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-		} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
-
-		case ShaderGraph::NODE_OUTPUT: {
-			gn->set_title("Output");
-
-			List<ShaderGraph::SlotInfo> si;
-			ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
-
-			int idx=0;
-			for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
-				ShaderGraph::SlotInfo& s=E->get();
-				if (s.dir==ShaderGraph::SLOT_OUT) {
-
-					Label *l= memnew( Label );
-					l->set_text(s.name);
-					l->set_align(Label::ALIGN_LEFT);
-					gn->add_child(l);
-					gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
-					idx++;
-				}
-			}
-
-		} break; // output (case Shader type dependent)
-		case ShaderGraph::NODE_COMMENT: {
-			gn->set_title("Comment");
-			TextEdit *te = memnew(TextEdit);
-			te->set_custom_minimum_size(Size2(100,100));
-			gn->add_child(te);
-			te->set_text(graph->comment_node_get_text(type,p_id));
-			te->connect("text_changed",this,"_comment_edited",varray(p_id,te));
-
-		} break; // comment
-
-
-
-	}
-
-	gn->connect("dragged",this,"_node_moved",varray(p_id));
-	gn->connect("close_request",this,"_node_removed",varray(p_id),CONNECT_DEFERRED);
-	graph_edit->add_child(gn);
-	node_map[p_id]=gn;
-	gn->set_offset(graph->node_get_pos(type,p_id));
+                } break; // vec3 interpolation  (with optional curve)
+                case ShaderGraph::NODE_COLOR_RAMP: {
+
+                        gn->set_title("ColorRamp");
+                        GraphColorRampEdit * ramp  = memnew( GraphColorRampEdit );
+
+                        DVector<real_t> offsets = graph->color_ramp_node_get_offsets(type,p_id);
+                        DVector<Color> colors = graph->color_ramp_node_get_colors(type,p_id);
+
+                        int oc = offsets.size();
+
+                        if (oc) {
+                                DVector<real_t>::Read rofs = offsets.read();
+                                DVector<Color>::Read rcol = colors.read();
+
+                                Vector<float> ofsv;
+                                Vector<Color> colorv;
+                                for(int i=0;i<oc;i++) {
+                                        ofsv.push_back(rofs[i]);
+                                        colorv.push_back(rcol[i]);
+                                }
+
+                                ramp->set_ramp(ofsv,colorv);
+
+                        }
+
+                        ramp->connect("ramp_changed",this,"_color_ramp_changed",varray(p_id,ramp));
+                        ramp->set_custom_minimum_size(Size2(128,1));
+                        gn->add_child(ramp);
+
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("c")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("rgb"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+                        l=memnew(Label("alpha"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child( l);
+
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(2,false,ShaderGraph::SLOT_MAX,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+                } break; // scalar interpolation (with optional curve)
+                case ShaderGraph::NODE_CURVE_MAP: {
+
+                        gn->set_title("CurveMap");
+                        GraphCurveMapEdit * map  = memnew( GraphCurveMapEdit );
+
+                        DVector<Vector2> points = graph->curve_map_node_get_points(type,p_id);
+
+                        int oc = points.size();
+
+                        if (oc) {
+                                DVector<Vector2>::Read rofs = points.read();
+
+
+                                Vector<Vector2> ofsv;
+                                for(int i=0;i<oc;i++) {
+                                        ofsv.push_back(rofs[i]);
+                                }
+
+                                map->set_points(ofsv);
+
+                        }
+                        map->connect("curve_changed",this,"_curve_changed",varray(p_id,map));
+
+                        //map->connect("map_changed",this,"_curve_map_changed",varray(p_id,map));
+                        map->set_custom_minimum_size(Size2(128,64));
+                        gn->add_child(map);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("c")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("cmap"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child( l);
+                        gn->add_child(hbc);
+
+
+                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+                } break; // scalar interpolation (with optional curve)
+
+                case ShaderGraph::NODE_SCALAR_INPUT: {
+
+                        gn->set_title("ScalarUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+                        SpinBox *sb = memnew( SpinBox );
+                        sb->set_min(-100000);
+                        sb->set_max(100000);
+                        sb->set_step(0.001);
+                        sb->set_val(graph->scalar_input_node_get_value(type,p_id));
+                        sb->connect("value_changed",this,"_scalar_input_changed",varray(p_id));
+                        gn->add_child(sb);
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; // scalar uniform (assignable in material)
+                case ShaderGraph::NODE_VEC_INPUT: {
+
+                        gn->set_title("VectorUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+                        Array v3p(true);
+                        for(int i=0;i<3;i++) {
+                                HBoxContainer *hbc = memnew( HBoxContainer );
+                                Label *l = memnew( Label );
+                                l->set_text(String::chr('X'+i));
+                                hbc->add_child(l);
+                                SpinBox *sb = memnew( SpinBox );
+                                sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
+                                sb->set_min(-100000);
+                                sb->set_max(100000);
+                                sb->set_step(0.001);
+                                sb->set_val(graph->vec_input_node_get_value(type,p_id)[i]);
+                                sb->connect("value_changed",this,"_vec_input_changed",varray(p_id,v3p));
+                                v3p.push_back(sb);
+                                hbc->add_child(sb);
+                                gn->add_child(hbc);
+                        }
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+                } break; // vec3 uniform (assignable in material)
+                case ShaderGraph::NODE_RGB_INPUT: {
+
+                        gn->set_title("ColorUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+                        ColorPickerButton *cpb = memnew( ColorPickerButton );
+                        cpb->set_color(graph->rgb_input_node_get_value(type,p_id));
+                        cpb->connect("color_changed",this,"_rgb_input_changed",varray(p_id));
+                        gn->add_child(cpb);
+                        Label *l = memnew( Label );
+                        l->set_text("RGB");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+                        l = memnew( Label );
+                        l->set_text("Alpha");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+
+                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+                } break; // color uniform (assignable in material)
+                case ShaderGraph::NODE_XFORM_INPUT: {
+                        gn->set_title("XFUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+                        ToolButton *edit = memnew( ToolButton );
+                        edit->set_text("edit..");
+                        edit->connect("pressed",this,"_xform_input_changed",varray(p_id,edit));
+                        gn->add_child(edit);
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+
+                } break; // mat4 uniform (assignable in material)
+                case ShaderGraph::NODE_TEXTURE_INPUT: {
+
+                        gn->set_title("TexUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+                        TextureFrame *tex = memnew( TextureFrame );
+                        tex->set_expand(true);
+                        tex->set_custom_minimum_size(Size2(80,80));
+                        gn->add_child(tex);
+                        tex->set_texture(graph->texture_input_node_get_value(type,p_id));
+                        ToolButton *edit = memnew( ToolButton );
+                        edit->set_text("edit..");
+                        edit->connect("pressed",this,"_tex_edited",varray(p_id,edit));
+                        gn->add_child(edit);
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("UV")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("RGB"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child(l);
+                        gn->add_child(hbc);
+                        l = memnew( Label );
+                        l->set_text("Alpha");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+
+                        gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(4,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; // texture input (assignable in material)
+                case ShaderGraph::NODE_CUBEMAP_INPUT: {
+
+                        gn->set_title("TexUniform");
+                        LineEdit *le = memnew( LineEdit );
+                        gn->add_child(le);
+                        le->set_text(graph->input_node_get_name(type,p_id));
+                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+
+                        ToolButton *edit = memnew( ToolButton );
+                        edit->set_text("edit..");
+                        edit->connect("pressed",this,"_cube_edited",varray(p_id,edit));
+                        gn->add_child(edit);
+
+
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("UV")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("RGB"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child(l);
+                        gn->add_child(hbc);
+                        l = memnew( Label );
+                        l->set_text("Alpha");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+
+                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+                } break; // cubemap input (assignable in material)
+                case ShaderGraph::NODE_DEFAULT_TEXTURE: {
+
+                        gn->set_title("CanvasItemTex");
+                        HBoxContainer *hbc = memnew( HBoxContainer );
+                        hbc->add_constant_override("separation",0);
+                        hbc->add_child( memnew(Label("UV")));
+                        hbc->add_spacer();
+                        Label *l=memnew(Label("RGB"));
+                        l->set_align(Label::ALIGN_RIGHT);
+                        hbc->add_child(l);
+                        gn->add_child(hbc);
+                        l = memnew( Label );
+                        l->set_text("Alpha");
+                        l->set_align(Label::ALIGN_RIGHT);
+                        gn->add_child(l);
+
+                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+                } break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
+
+                case ShaderGraph::NODE_OUTPUT: {
+                        gn->set_title("Output");
+                        gn->set_show_close_button(false);
+
+                        List<ShaderGraph::SlotInfo> si;
+                        ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
+
+                        int idx=0;
+                        for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
+                                ShaderGraph::SlotInfo& s=E->get();
+                                if (s.dir==ShaderGraph::SLOT_OUT) {
+
+                                        Label *l= memnew( Label );
+                                        l->set_text(s.name);
+                                        l->set_align(Label::ALIGN_LEFT);
+                                        gn->add_child(l);
+                                        gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
+                                        idx++;
+                                }
+                        }
+
+                } break; // output (case Shader type dependent)
+                case ShaderGraph::NODE_COMMENT: {
+                        gn->set_title("Comment");
+                        TextEdit *te = memnew(TextEdit);
+                        te->set_custom_minimum_size(Size2(100,100));
+                        gn->add_child(te);
+                        te->set_text(graph->comment_node_get_text(type,p_id));
+                        te->connect("text_changed",this,"_comment_edited",varray(p_id,te));
+
+                } break; // comment
+
+
+
+        }
+
+        gn->connect("dragged",this,"_node_moved",varray(p_id));
+        gn->connect("close_request",this,"_node_removed",varray(p_id),CONNECT_DEFERRED);
+        graph_edit->add_child(gn);
+        node_map[p_id]=gn;
+        gn->set_offset(graph->node_get_pos(type,p_id));
 
 
 }
@@ -2045,36 +2056,36 @@ void ShaderGraphView::_create_node(int p_id) {
 void ShaderGraphView::_update_graph() {
 
 
-	if (block_update)
-		return;
+        if (block_update)
+                return;
 
-	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-		memdelete(E->get());
-	}
+                memdelete(E->get());
+        }
 
-	node_map.clear();
+        node_map.clear();
 
-	if (!graph.is_valid())
-		return;
+        if (!graph.is_valid())
+                return;
 
 
-	List<int> nl;
-	graph->get_node_list(type,&nl);
+        List<int> nl;
+        graph->get_node_list(type,&nl);
 
-	for(List<int>::Element *E=nl.front();E;E=E->next()) {
+        for(List<int>::Element *E=nl.front();E;E=E->next()) {
 
-		_create_node(E->get());
-	}
-	graph_edit->clear_connections();
+                _create_node(E->get());
+        }
+        graph_edit->clear_connections();
 
-	List<ShaderGraph::Connection> connections;
-	graph->get_node_connections(type,&connections);
-	for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
+        List<ShaderGraph::Connection> connections;
+        graph->get_node_connections(type,&connections);
+        for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
 
-		ERR_CONTINUE(!node_map.has(E->get().src_id) || !node_map.has(E->get().dst_id));
-		graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
-	}
+                ERR_CONTINUE(!node_map.has(E->get().src_id) || !node_map.has(E->get().dst_id));
+                graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
+        }
 
 
 
@@ -2082,305 +2093,309 @@ void ShaderGraphView::_update_graph() {
 
 void ShaderGraphView::_sg_updated() {
 
-	if (!graph.is_valid())
-		return;
-	switch(graph->get_graph_error(type)) {
-		case ShaderGraph::GRAPH_OK: status->set_text(""); break;
-		case ShaderGraph::GRAPH_ERROR_CYCLIC: status->set_text("Error: Cyclic Connection Link"); break;
-		case ShaderGraph::GRAPH_ERROR_MISSING_CONNECTIONS: status->set_text("Error: Missing Input Connections"); break;
-	}
+        if (!graph.is_valid())
+                return;
+        switch(graph->get_graph_error(type)) {
+                case ShaderGraph::GRAPH_OK: status->set_text(""); break;
+                case ShaderGraph::GRAPH_ERROR_CYCLIC: status->set_text("Error: Cyclic Connection Link"); break;
+                case ShaderGraph::GRAPH_ERROR_MISSING_CONNECTIONS: status->set_text("Error: Missing Input Connections"); break;
+        }
 }
 
 void ShaderGraphView::set_graph(Ref<ShaderGraph> p_graph){
 
 
-	if (graph.is_valid()) {
-		graph->disconnect("updated",this,"_sg_updated");
-	}
-	graph=p_graph;
-	if (graph.is_valid()) {
-		graph->connect("updated",this,"_sg_updated");
-	}
-	_update_graph();
-	_sg_updated();
+        if (graph.is_valid()) {
+                graph->disconnect("updated",this,"_sg_updated");
+        }
+        graph=p_graph;
+        if (graph.is_valid()) {
+                graph->connect("updated",this,"_sg_updated");
+        }
+        _update_graph();
+        _sg_updated();
 
 }
 
 void ShaderGraphView::_notification(int p_what) {
 
-	if (p_what==NOTIFICATION_ENTER_TREE) {
+        if (p_what==NOTIFICATION_ENTER_TREE) {
 
-		ped_popup->connect("variant_changed",this,"_variant_edited");
-	}
+                ped_popup->connect("variant_changed",this,"_variant_edited");
+        }
  }
 
 void ShaderGraphView::add_node(int p_type, const Vector2 &location) {
 
-	List<int> existing;
-	graph->get_node_list(type,&existing);
-	existing.sort();
-	int newid=1;
-	for(List<int>::Element *E=existing.front();E;E=E->next()) {
-		if (!E->next() || (E->get()+1!=E->next()->get())){
-			newid=E->get()+1;
-			break;
-		}
-	}
-
-    Vector2 init_ofs = location;
-	while(true) {
-		bool valid=true;
-		for(List<int>::Element *E=existing.front();E;E=E->next()) {
-			Vector2 pos = graph->node_get_pos(type,E->get());
-			if (init_ofs==pos) {
-				init_ofs+=Vector2(20,20);
-				valid=false;
-				break;
-
-			}
-		}
-
-		if (valid)
-			break;
-	}
-	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-	ur->create_action("Add Shader Graph Node");
-	ur->add_do_method(graph.ptr(),"node_add",type,p_type,newid);
-	ur->add_do_method(graph.ptr(),"node_set_pos",type,newid,init_ofs);
-	ur->add_undo_method(graph.ptr(),"node_remove",type,newid);
-	ur->add_do_method(this,"_update_graph");
-	ur->add_undo_method(this,"_update_graph");
-	ur->commit_action();
+        List<int> existing;
+        graph->get_node_list(type,&existing);
+        existing.sort();
+        int newid=1;
+        for(List<int>::Element *E=existing.front();E;E=E->next()) {
+                if (!E->next() || (E->get()+1!=E->next()->get())){
+                        newid=E->get()+1;
+                        break;
+                }
+        }
+
+        Vector2 init_ofs = location;
+        while(true) {
+                bool valid=true;
+                for(List<int>::Element *E=existing.front();E;E=E->next()) {
+                        Vector2 pos = graph->node_get_pos(type,E->get());
+                        if (init_ofs==pos) {
+                                init_ofs+=Vector2(20,20);
+                                valid=false;
+                                break;
+
+                        }
+                }
+
+                if (valid)
+                        break;
+        }
+        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+        ur->create_action("Add Shader Graph Node");
+        ur->add_do_method(graph.ptr(),"node_add",type,p_type,newid);
+        ur->add_do_method(graph.ptr(),"node_set_pos",type,newid,init_ofs);
+        ur->add_undo_method(graph.ptr(),"node_remove",type,newid);
+        ur->add_do_method(this,"_update_graph");
+        ur->add_undo_method(this,"_update_graph");
+        ur->commit_action();
 
 }
 
 void ShaderGraphView::_bind_methods() {
 
-	ObjectTypeDB::bind_method("_update_graph",&ShaderGraphView::_update_graph);
-	ObjectTypeDB::bind_method("_node_moved",&ShaderGraphView::_node_moved);
-	ObjectTypeDB::bind_method("_move_node",&ShaderGraphView::_move_node);
-	ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
-	ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
-	ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
-
-	ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
-	ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
-	ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
-	ObjectTypeDB::bind_method("_xform_const_changed",&ShaderGraphView::_xform_const_changed);
-	ObjectTypeDB::bind_method("_scalar_op_changed",&ShaderGraphView::_scalar_op_changed);
-	ObjectTypeDB::bind_method("_vec_op_changed",&ShaderGraphView::_vec_op_changed);
-	ObjectTypeDB::bind_method("_vec_scalar_op_changed",&ShaderGraphView::_vec_scalar_op_changed);
-	ObjectTypeDB::bind_method("_rgb_op_changed",&ShaderGraphView::_rgb_op_changed);
-	ObjectTypeDB::bind_method("_xform_inv_rev_changed",&ShaderGraphView::_xform_inv_rev_changed);
-	ObjectTypeDB::bind_method("_scalar_func_changed",&ShaderGraphView::_scalar_func_changed);
-	ObjectTypeDB::bind_method("_vec_func_changed",&ShaderGraphView::_vec_func_changed);
-	ObjectTypeDB::bind_method("_scalar_input_changed",&ShaderGraphView::_scalar_input_changed);
-	ObjectTypeDB::bind_method("_vec_input_changed",&ShaderGraphView::_vec_input_changed);
-	ObjectTypeDB::bind_method("_xform_input_changed",&ShaderGraphView::_xform_input_changed);
-	ObjectTypeDB::bind_method("_rgb_input_changed",&ShaderGraphView::_rgb_input_changed);
-	ObjectTypeDB::bind_method("_tex_input_change",&ShaderGraphView::_tex_input_change);
-	ObjectTypeDB::bind_method("_cube_input_change",&ShaderGraphView::_cube_input_change);
-	ObjectTypeDB::bind_method("_input_name_changed",&ShaderGraphView::_input_name_changed);
-	ObjectTypeDB::bind_method("_tex_edited",&ShaderGraphView::_tex_edited);
-	ObjectTypeDB::bind_method("_variant_edited",&ShaderGraphView::_variant_edited);
-	ObjectTypeDB::bind_method("_cube_edited",&ShaderGraphView::_cube_edited);
-	ObjectTypeDB::bind_method("_comment_edited",&ShaderGraphView::_comment_edited);
-	ObjectTypeDB::bind_method("_color_ramp_changed",&ShaderGraphView::_color_ramp_changed);
-	ObjectTypeDB::bind_method("_curve_changed",&ShaderGraphView::_curve_changed);
-
-	ObjectTypeDB::bind_method("_sg_updated",&ShaderGraphView::_sg_updated);
+        ObjectTypeDB::bind_method("_update_graph",&ShaderGraphView::_update_graph);
+        ObjectTypeDB::bind_method("_begin_node_move", &ShaderGraphView::_begin_node_move);
+        ObjectTypeDB::bind_method("_node_moved",&ShaderGraphView::_node_moved);
+        ObjectTypeDB::bind_method("_end_node_move", &ShaderGraphView::_end_node_move);
+        ObjectTypeDB::bind_method("_move_node",&ShaderGraphView::_move_node);
+        ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
+        ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
+        ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
+
+        ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
+        ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
+        ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
+        ObjectTypeDB::bind_method("_xform_const_changed",&ShaderGraphView::_xform_const_changed);
+        ObjectTypeDB::bind_method("_scalar_op_changed",&ShaderGraphView::_scalar_op_changed);
+        ObjectTypeDB::bind_method("_vec_op_changed",&ShaderGraphView::_vec_op_changed);
+        ObjectTypeDB::bind_method("_vec_scalar_op_changed",&ShaderGraphView::_vec_scalar_op_changed);
+        ObjectTypeDB::bind_method("_rgb_op_changed",&ShaderGraphView::_rgb_op_changed);
+        ObjectTypeDB::bind_method("_xform_inv_rev_changed",&ShaderGraphView::_xform_inv_rev_changed);
+        ObjectTypeDB::bind_method("_scalar_func_changed",&ShaderGraphView::_scalar_func_changed);
+        ObjectTypeDB::bind_method("_vec_func_changed",&ShaderGraphView::_vec_func_changed);
+        ObjectTypeDB::bind_method("_scalar_input_changed",&ShaderGraphView::_scalar_input_changed);
+        ObjectTypeDB::bind_method("_vec_input_changed",&ShaderGraphView::_vec_input_changed);
+        ObjectTypeDB::bind_method("_xform_input_changed",&ShaderGraphView::_xform_input_changed);
+        ObjectTypeDB::bind_method("_rgb_input_changed",&ShaderGraphView::_rgb_input_changed);
+        ObjectTypeDB::bind_method("_tex_input_change",&ShaderGraphView::_tex_input_change);
+        ObjectTypeDB::bind_method("_cube_input_change",&ShaderGraphView::_cube_input_change);
+        ObjectTypeDB::bind_method("_input_name_changed",&ShaderGraphView::_input_name_changed);
+        ObjectTypeDB::bind_method("_tex_edited",&ShaderGraphView::_tex_edited);
+        ObjectTypeDB::bind_method("_variant_edited",&ShaderGraphView::_variant_edited);
+        ObjectTypeDB::bind_method("_cube_edited",&ShaderGraphView::_cube_edited);
+        ObjectTypeDB::bind_method("_comment_edited",&ShaderGraphView::_comment_edited);
+        ObjectTypeDB::bind_method("_color_ramp_changed",&ShaderGraphView::_color_ramp_changed);
+        ObjectTypeDB::bind_method("_curve_changed",&ShaderGraphView::_curve_changed);
+
+        ObjectTypeDB::bind_method("_sg_updated",&ShaderGraphView::_sg_updated);
 }
 
 ShaderGraphView::ShaderGraphView(ShaderGraph::ShaderType p_type) {
 
-	type=p_type;
-	graph_edit = memnew( GraphEdit );
-	block_update=false;
-	ped_popup = memnew( CustomPropertyEditor );
-	graph_edit->add_child(ped_popup);
-	status = memnew( Label );
-	graph_edit->get_top_layer()->add_child(status);
-	status->set_pos(Vector2(5,5));
-	status->add_color_override("font_color_shadow",Color(0,0,0));
-	status->add_color_override("font_color",Color(1,0.4,0.3));
-	status->add_constant_override("shadow_as_outline",1);
-	status->add_constant_override("shadow_offset_x",2);
-	status->add_constant_override("shadow_offset_y",2);
-	status->set_text("");
+        type=p_type;
+        graph_edit = memnew( GraphEdit );
+        block_update=false;
+        ped_popup = memnew( CustomPropertyEditor );
+        graph_edit->add_child(ped_popup);
+        status = memnew( Label );
+        graph_edit->get_top_layer()->add_child(status);
+        graph_edit->connect("_begin_node_move", this, "_begin_node_move");
+        graph_edit->connect("_end_node_move", this, "_end_node_move");
+        status->set_pos(Vector2(5,5));
+        status->add_color_override("font_color_shadow",Color(0,0,0));
+        status->add_color_override("font_color",Color(1,0.4,0.3));
+        status->add_constant_override("shadow_as_outline",1);
+        status->add_constant_override("shadow_offset_x",2);
+        status->add_constant_override("shadow_offset_y",2);
+        status->set_text("");
 }
 
 
 //////////////edit//////////////
 void ShaderGraphEditor::edit(Ref<ShaderGraph> p_shader) {
 
-	for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
-		graph_edits[i]->set_graph(p_shader);
-	}
+        for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
+                graph_edits[i]->set_graph(p_shader);
+        }
 }
 
 void ShaderGraphEditor::_add_node(int p_type) {
 
-	ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
+        ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
 
-    graph_edits[shader_type]->add_node(p_type, next_location);
+        graph_edits[shader_type]->add_node(p_type, next_location);
 }
 
 void ShaderGraphEditor::_popup_requested(const Vector2 &p_position)
 {
-    next_location = get_local_mouse_pos();
-    popup->set_global_pos(p_position);
-    popup->set_size( Size2( 200, 0) );
-    popup->popup();
-    popup->call_deferred("grab_click_focus");
-    popup->set_invalidate_click_until_motion();
+        next_location = get_local_mouse_pos();
+        popup->set_global_pos(p_position);
+        popup->set_size( Size2( 200, 0) );
+        popup->popup();
+        popup->call_deferred("grab_click_focus");
+        popup->set_invalidate_click_until_motion();
 }
 
 
 void ShaderGraphEditor::_notification(int p_what) {
-	if (p_what==NOTIFICATION_ENTER_TREE) {
+        if (p_what==NOTIFICATION_ENTER_TREE) {
 
-		for(int i=0;i<ShaderGraph::NODE_TYPE_MAX;i++) {
+                for(int i=0;i<ShaderGraph::NODE_TYPE_MAX;i++) {
 
-			if (i==ShaderGraph::NODE_OUTPUT)
-				continue;
-			if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
-				continue;
+                        if (i==ShaderGraph::NODE_OUTPUT)
+                                continue;
+                        if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
+                                continue;
 
-			String nn = node_names[i];
-			String ic = nn.get_slice(":",0);
-			String v = nn.get_slice(":",1);
-			bool addsep=false;
-			if (nn.ends_with(":")) {
-				addsep=true;
-			}
-            popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
-			if (addsep)
-                popup->add_separator();
-		}
-        popup->connect("item_pressed",this,"_add_node");
+                        String nn = node_names[i];
+                        String ic = nn.get_slice(":",0);
+                        String v = nn.get_slice(":",1);
+                        bool addsep=false;
+                        if (nn.ends_with(":")) {
+                                addsep=true;
+                        }
+                        popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
+                        if (addsep)
+                                popup->add_separator();
+                }
+                popup->connect("item_pressed",this,"_add_node");
 
 
-	}
+        }
 }
 
 void ShaderGraphEditor::_bind_methods() {
 
-	ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
-    ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
+        ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
+        ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
 }
 
 
 const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
-	"GraphInput:Input", // all inputs (shader type dependent)
-	"GraphScalar:Scalar Constant", //scalar constant
-	"GraphVector:Vector Constant", //vec3 constant
-	"GraphRgb:RGB Constant", //rgb constant (shows a color picker instead)
-	"GraphXform:XForm Constant", // 4x4 matrix constant
-	"GraphTime:Time:", // time in seconds
-	"GraphTexscreen:Screen Sample", // screen texture sampler (takes uv) (only usable in fragment shader)
-	"GraphScalarOp:Scalar Operator", // scalar vs scalar op (mul", add", div", etc)
-	"GraphVecOp:Vector Operator", // vec3 vs vec3 op (mul",ad",div",crossprod",etc)
-	"GraphVecScalarOp:Scalar+Vector Operator", // vec3 vs scalar op (mul", add", div", etc)
-	"GraphRgbOp:RGB Operator:", // vec3 vs vec3 rgb op (with scalar amount)", like brighten", darken", burn", dodge", multiply", etc.
-	"GraphXformMult:XForm Multiply", // mat4 x mat4
-	"GraphXformVecMult:XForm+Vector Multiply", // mat4 x vec3 mult (with no-translation option)
-	"GraphXformVecImult:Form+Vector InvMultiply:", // mat4 x vec3 inverse mult (with no-translation option)
-	"GraphXformScalarFunc:Scalar Function", // scalar function (sin", cos", etc)
-	"GraphXformVecFunc:Vector Function", // vector function (normalize", negate", reciprocal", rgb2hsv", hsv2rgb", etc", etc)
-	"GraphVecLength:Vector Length", // vec3 length
-	"GraphVecDp:Dot Product:", // vec3 . vec3 (dot product -> scalar output)
-	"GraphVecToScalars:Vector -> Scalars", // 1 vec3 input", 3 scalar outputs
-	"GraphScalarsToVec:Scalars -> Vector", // 3 scalar input", 1 vec3 output
-	"GraphXformToVecs:XForm -> Vectors", // 3 vec input", 1 xform output
-	"GraphVecsToXform:Vectors -> XForm:", // 3 vec input", 1 xform output
-	"GraphScalarInterp:Scalar Interpolate", // scalar interpolation (with optional curve)
-	"GraphVecInterp:Vector Interpolate:", // vec3 interpolation  (with optional curve)
-    "GraphColorRamp:Color Ramp", // vec3 interpolation  (with optional curve)
-    "GraphCurveMap:Curve Remap:", // vec3 interpolation  (with optional curve)
-    "GraphScalarUniform:Scalar Uniform", // scalar uniform (assignable in material)
-	"GraphVectorUniform:Vector Uniform", // vec3 uniform (assignable in material)
-	"GraphRgbUniform:RGB Uniform", // color uniform (assignable in material)
-	"GraphXformUniform:XForm Uniform", // mat4 uniform (assignable in material)
-	"GraphTextureUniform:Texture Uniform", // texture input (assignable in material)
-	"GraphCubeUniform:CubeMap Uniform:", // cubemap input (assignable in material)
-    "GraphDefaultTexture:CanvasItem Texture:", // cubemap input (assignable in material)
-    "Output", // output (shader type dependent)
-	"GraphComment:Comment", // comment
+        "GraphInput:Input", // all inputs (shader type dependent)
+        "GraphScalar:Scalar Constant", //scalar constant
+        "GraphVector:Vector Constant", //vec3 constant
+        "GraphRgb:RGB Constant", //rgb constant (shows a color picker instead)
+        "GraphXform:XForm Constant", // 4x4 matrix constant
+        "GraphTime:Time:", // time in seconds
+        "GraphTexscreen:Screen Sample", // screen texture sampler (takes uv) (only usable in fragment shader)
+        "GraphScalarOp:Scalar Operator", // scalar vs scalar op (mul", add", div", etc)
+        "GraphVecOp:Vector Operator", // vec3 vs vec3 op (mul",ad",div",crossprod",etc)
+        "GraphVecScalarOp:Scalar+Vector Operator", // vec3 vs scalar op (mul", add", div", etc)
+        "GraphRgbOp:RGB Operator:", // vec3 vs vec3 rgb op (with scalar amount)", like brighten", darken", burn", dodge", multiply", etc.
+        "GraphXformMult:XForm Multiply", // mat4 x mat4
+        "GraphXformVecMult:XForm+Vector Multiply", // mat4 x vec3 mult (with no-translation option)
+        "GraphXformVecImult:Form+Vector InvMultiply:", // mat4 x vec3 inverse mult (with no-translation option)
+        "GraphXformScalarFunc:Scalar Function", // scalar function (sin", cos", etc)
+        "GraphXformVecFunc:Vector Function", // vector function (normalize", negate", reciprocal", rgb2hsv", hsv2rgb", etc", etc)
+        "GraphVecLength:Vector Length", // vec3 length
+        "GraphVecDp:Dot Product:", // vec3 . vec3 (dot product -> scalar output)
+        "GraphVecToScalars:Vector -> Scalars", // 1 vec3 input", 3 scalar outputs
+        "GraphScalarsToVec:Scalars -> Vector", // 3 scalar input", 1 vec3 output
+        "GraphXformToVecs:XForm -> Vectors", // 3 vec input", 1 xform output
+        "GraphVecsToXform:Vectors -> XForm:", // 3 vec input", 1 xform output
+        "GraphScalarInterp:Scalar Interpolate", // scalar interpolation (with optional curve)
+        "GraphVecInterp:Vector Interpolate:", // vec3 interpolation  (with optional curve)
+        "GraphColorRamp:Color Ramp", // vec3 interpolation  (with optional curve)
+        "GraphCurveMap:Curve Remap:", // vec3 interpolation  (with optional curve)
+        "GraphScalarUniform:Scalar Uniform", // scalar uniform (assignable in material)
+        "GraphVectorUniform:Vector Uniform", // vec3 uniform (assignable in material)
+        "GraphRgbUniform:RGB Uniform", // color uniform (assignable in material)
+        "GraphXformUniform:XForm Uniform", // mat4 uniform (assignable in material)
+        "GraphTextureUniform:Texture Uniform", // texture input (assignable in material)
+        "GraphCubeUniform:CubeMap Uniform:", // cubemap input (assignable in material)
+        "GraphDefaultTexture:CanvasItem Texture:", // cubemap input (assignable in material)
+        "Output", // output (shader type dependent)
+        "GraphComment:Comment", // comment
 
 
 };
 ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
-	_2d=p_2d;
+        _2d=p_2d;
 
-    HBoxContainer *hbc = memnew( HBoxContainer );
-    popup = memnew( PopupMenu );
-    hbc->add_child(popup);
-    add_child(hbc);
+        HBoxContainer *hbc = memnew( HBoxContainer );
+        popup = memnew( PopupMenu );
+        hbc->add_child(popup);
+        add_child(hbc);
 
 
-	tabs = memnew(TabContainer);
-	tabs->set_v_size_flags(SIZE_EXPAND_FILL);
-	add_child(tabs);
-	const char* sname[ShaderGraph::SHADER_TYPE_MAX]={
-		"Vertex",
-		"Fragment",
-		"Light"
-	};
-	for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
+        tabs = memnew(TabContainer);
+        tabs->set_v_size_flags(SIZE_EXPAND_FILL);
+        add_child(tabs);
+        const char* sname[ShaderGraph::SHADER_TYPE_MAX]={
+                "Vertex",
+                "Fragment",
+                "Light"
+        };
+        for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
 
-		graph_edits[i]= memnew( ShaderGraphView(ShaderGraph::ShaderType(i)) );
-		add_child(graph_edits[i]);
-		graph_edits[i]->get_graph_edit()->set_name(sname[i]);
-		tabs->add_child(graph_edits[i]->get_graph_edit());
-		graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
-		graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
-        graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
-        graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
-	}
+                graph_edits[i]= memnew( ShaderGraphView(ShaderGraph::ShaderType(i)) );
+                add_child(graph_edits[i]);
+                graph_edits[i]->get_graph_edit()->set_name(sname[i]);
+                tabs->add_child(graph_edits[i]->get_graph_edit());
+                graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
+                graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
+                graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
+                graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
+        }
 
-	tabs->set_current_tab(1);
+        tabs->set_current_tab(1);
 
-	set_custom_minimum_size(Size2(100,300));
+        set_custom_minimum_size(Size2(100,300));
 }
 
 
 void ShaderGraphEditorPlugin::edit(Object *p_object) {
 
-	shader_editor->edit(p_object->cast_to<ShaderGraph>());
+        shader_editor->edit(p_object->cast_to<ShaderGraph>());
 }
 
 bool ShaderGraphEditorPlugin::handles(Object *p_object) const {
 
-	ShaderGraph *shader=p_object->cast_to<ShaderGraph>();
-	if (!shader)
-		return false;
-	if (_2d)
-		return shader->get_mode()==Shader::MODE_CANVAS_ITEM;
-	else
-		return shader->get_mode()==Shader::MODE_MATERIAL;
+        ShaderGraph *shader=p_object->cast_to<ShaderGraph>();
+        if (!shader)
+                return false;
+        if (_2d)
+                return shader->get_mode()==Shader::MODE_CANVAS_ITEM;
+        else
+                return shader->get_mode()==Shader::MODE_MATERIAL;
 }
 
 void ShaderGraphEditorPlugin::make_visible(bool p_visible) {
 
-	if (p_visible) {
-		shader_editor->show();
-	} else {
+        if (p_visible) {
+                shader_editor->show();
+        } else {
 
-		shader_editor->hide();
-	}
+                shader_editor->hide();
+        }
 
 }
 
 ShaderGraphEditorPlugin::ShaderGraphEditorPlugin(EditorNode *p_node, bool p_2d) {
 
-	_2d=p_2d;
-	editor=p_node;
-	shader_editor = memnew( ShaderGraphEditor(p_2d) );
-	shader_editor->hide();
-	if (p_2d)
-		CanvasItemEditor::get_singleton()->get_bottom_split()->add_child(shader_editor);
-	else
-		SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);
+        _2d=p_2d;
+        editor=p_node;
+        shader_editor = memnew( ShaderGraphEditor(p_2d) );
+        shader_editor->hide();
+        if (p_2d)
+                CanvasItemEditor::get_singleton()->get_bottom_split()->add_child(shader_editor);
+        else
+                SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);
 
 
 //	editor->get_viewport()->add_child(shader_editor);
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index c41ec68360..ea21a7706f 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -41,187 +41,189 @@
 #include "tools/editor/property_editor.h"
 #include "scene/resources/shader_graph.h"
 /**
-	@author Juan Linietsky <reduzio@gmail.com>
+    @author Juan Linietsky <reduzio@gmail.com>
 */
 
 
 class GraphColorRampEdit : public Control {
 
-	OBJ_TYPE(GraphColorRampEdit,Control);
+    OBJ_TYPE(GraphColorRampEdit,Control);
 
 
-	struct Point {
+    struct Point {
 
-		float offset;
-		Color color;
-		bool operator<(const Point& p_ponit) const {
-			return offset<p_ponit.offset;
-		}
-	};
+        float offset;
+        Color color;
+        bool operator<(const Point& p_ponit) const {
+            return offset<p_ponit.offset;
+        }
+    };
 
-	PopupPanel *popup;
-	ColorPicker *picker;
+    PopupPanel *popup;
+    ColorPicker *picker;
 
 
-	bool grabbing;
-	int grabbed;
-	float grabbed_at;
-	Vector<Point> points;
+    bool grabbing;
+    int grabbed;
+    float grabbed_at;
+    Vector<Point> points;
 
-	void _color_changed(const Color& p_color);
+    void _color_changed(const Color& p_color);
 
 protected:
-	void _input_event(const InputEvent& p_event);
-	void _notification(int p_what);
-	static void _bind_methods();
+    void _input_event(const InputEvent& p_event);
+    void _notification(int p_what);
+    static void _bind_methods();
 public:
 
-	void set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors);
-	Vector<float> get_offsets() const;
-	Vector<Color> get_colors() const;
-	virtual Size2 get_minimum_size() const;
-	GraphColorRampEdit();
+    void set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors);
+    Vector<float> get_offsets() const;
+    Vector<Color> get_colors() const;
+    virtual Size2 get_minimum_size() const;
+    GraphColorRampEdit();
 };
 
 
 class GraphCurveMapEdit : public Control {
 
-	OBJ_TYPE(GraphCurveMapEdit,Control);
+    OBJ_TYPE(GraphCurveMapEdit,Control);
 
 
-	struct Point {
+    struct Point {
 
-		float offset;
-		float height;
-		bool operator<(const Point& p_ponit) const {
-			return offset<p_ponit.offset;
-		}
-	};
+        float offset;
+        float height;
+        bool operator<(const Point& p_ponit) const {
+            return offset<p_ponit.offset;
+        }
+    };
 
 
-	bool grabbing;
-	int grabbed;
-	Vector<Point> points;
+    bool grabbing;
+    int grabbed;
+    Vector<Point> points;
 
-	void _plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d);
+    void _plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d);
 protected:
-	void _input_event(const InputEvent& p_event);
-	void _notification(int p_what);
-	static void _bind_methods();
+    void _input_event(const InputEvent& p_event);
+    void _notification(int p_what);
+    static void _bind_methods();
 public:
 
-	void set_points(const Vector<Vector2>& p_points);
-	Vector<Vector2> get_points() const;
-	virtual Size2 get_minimum_size() const;
-	GraphCurveMapEdit();
+    void set_points(const Vector<Vector2>& p_points);
+    Vector<Vector2> get_points() const;
+    virtual Size2 get_minimum_size() const;
+    GraphCurveMapEdit();
 };
 
 class ShaderGraphView : public Node {
 
-	OBJ_TYPE(ShaderGraphView,Node);
-
-
-
-	CustomPropertyEditor *ped_popup;
-	bool block_update;
-
-	Label *status;
-	GraphEdit *graph_edit;
-	Ref<ShaderGraph> graph;
-	int edited_id;
-
-	ShaderGraph::ShaderType type;
-
-	void _update_graph();
-	void _create_node(int p_id);
-
-
-
-	void _connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
-	void _disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
-
-	void _node_removed(int p_id);
-	void _node_moved(const Vector2& p_from, const Vector2& p_to,int p_id);
-	void _move_node(int p_id,const Vector2& p_to);
-
-	void _scalar_const_changed(double p_value,int p_id);
-	void _vec_const_changed(double p_value, int p_id, Array p_arr);
-	void _rgb_const_changed(const Color& p_color, int p_id);
-	void _xform_const_changed(int p_id,Node* p_button);
-	void _scalar_op_changed(int p_op, int p_id);
-	void _vec_op_changed(int p_op, int p_id);
-	void _vec_scalar_op_changed(int p_op, int p_id);
-	void _rgb_op_changed(int p_op, int p_id);
-	void _xform_inv_rev_changed(bool p_enabled, int p_id);
-	void _scalar_func_changed(int p_func, int p_id);
-	void _vec_func_changed(int p_func, int p_id);
-	void _scalar_input_changed(double p_value,int p_id);
-	void _vec_input_changed(double p_value, int p_id, Array p_arr);
-	void _xform_input_changed(int p_id,Node* p_button);
-	void _rgb_input_changed(const Color& p_color, int p_id);
-	void _tex_input_change(int p_id,Node* p_button);
-	void _cube_input_change(int p_id);
-	void _input_name_changed(const String& p_name,int p_id,Node* p_line_edit);
-	void _tex_edited(int p_id,Node* p_button);
-	void _cube_edited(int p_id,Node* p_button);
-	void _variant_edited();
-	void _comment_edited(int p_id,Node* p_button);
-	void _color_ramp_changed(int p_id,Node* p_ramp);
-	void _curve_changed(int p_id,Node* p_curve);
-	void _sg_updated();
-	Map<int,GraphNode*> node_map;
+    OBJ_TYPE(ShaderGraphView,Node);
+
+
+
+    CustomPropertyEditor *ped_popup;
+    bool block_update;
+
+    Label *status;
+    GraphEdit *graph_edit;
+    Ref<ShaderGraph> graph;
+    int edited_id;
+
+    ShaderGraph::ShaderType type;
+
+    void _update_graph();
+    void _create_node(int p_id);
+
+
+
+    void _connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
+    void _disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
+
+    void _node_removed(int p_id);
+    void _begin_node_move();
+    void _node_moved(const Vector2& p_from, const Vector2& p_to,int p_id);
+    void _end_node_move();
+    void _move_node(int p_id,const Vector2& p_to);
+
+    void _scalar_const_changed(double p_value,int p_id);
+    void _vec_const_changed(double p_value, int p_id, Array p_arr);
+    void _rgb_const_changed(const Color& p_color, int p_id);
+    void _xform_const_changed(int p_id,Node* p_button);
+    void _scalar_op_changed(int p_op, int p_id);
+    void _vec_op_changed(int p_op, int p_id);
+    void _vec_scalar_op_changed(int p_op, int p_id);
+    void _rgb_op_changed(int p_op, int p_id);
+    void _xform_inv_rev_changed(bool p_enabled, int p_id);
+    void _scalar_func_changed(int p_func, int p_id);
+    void _vec_func_changed(int p_func, int p_id);
+    void _scalar_input_changed(double p_value,int p_id);
+    void _vec_input_changed(double p_value, int p_id, Array p_arr);
+    void _xform_input_changed(int p_id,Node* p_button);
+    void _rgb_input_changed(const Color& p_color, int p_id);
+    void _tex_input_change(int p_id,Node* p_button);
+    void _cube_input_change(int p_id);
+    void _input_name_changed(const String& p_name,int p_id,Node* p_line_edit);
+    void _tex_edited(int p_id,Node* p_button);
+    void _cube_edited(int p_id,Node* p_button);
+    void _variant_edited();
+    void _comment_edited(int p_id,Node* p_button);
+    void _color_ramp_changed(int p_id,Node* p_ramp);
+    void _curve_changed(int p_id,Node* p_curve);
+    void _sg_updated();
+    Map<int,GraphNode*> node_map;
 protected:
-	void _notification(int p_what);
-	static void _bind_methods();
+    void _notification(int p_what);
+    static void _bind_methods();
 public:
 
     void add_node(int p_type, const Vector2 &location);
-	GraphEdit *get_graph_edit() { return graph_edit; }
-	void set_graph(Ref<ShaderGraph> p_graph);
+    GraphEdit *get_graph_edit() { return graph_edit; }
+    void set_graph(Ref<ShaderGraph> p_graph);
 
-	ShaderGraphView(ShaderGraph::ShaderType p_type=ShaderGraph::SHADER_TYPE_FRAGMENT);
+    ShaderGraphView(ShaderGraph::ShaderType p_type=ShaderGraph::SHADER_TYPE_FRAGMENT);
 };
 
 class ShaderGraphEditor : public VBoxContainer {
 
-	OBJ_TYPE(ShaderGraphEditor,VBoxContainer);
+    OBJ_TYPE(ShaderGraphEditor,VBoxContainer);
 
     PopupMenu *popup;
-	TabContainer *tabs;
-	ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
-	static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
+    TabContainer *tabs;
+    ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
+    static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
     Vector2 next_location;
 
-	bool _2d;
-	void _add_node(int p_type);
+    bool _2d;
+    void _add_node(int p_type);
     void _popup_requested(const Vector2 &p_position);
 protected:
-	void _notification(int p_what);
-	static void _bind_methods();
+    void _notification(int p_what);
+    static void _bind_methods();
 public:
 
-	void edit(Ref<ShaderGraph> p_shader);
-	ShaderGraphEditor(bool p_2d);
+    void edit(Ref<ShaderGraph> p_shader);
+    ShaderGraphEditor(bool p_2d);
 };
 
 class ShaderGraphEditorPlugin : public EditorPlugin {
 
-	OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin );
+    OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin );
 
-	bool _2d;
-	ShaderGraphEditor *shader_editor;
-	EditorNode *editor;
+    bool _2d;
+    ShaderGraphEditor *shader_editor;
+    EditorNode *editor;
 
 public:
 
-	virtual String get_name() const { return "ShaderGraph"; }
-	bool has_main_screen() const { return false; }
-	virtual void edit(Object *p_node);
-	virtual bool handles(Object *p_node) const;
-	virtual void make_visible(bool p_visible);
+    virtual String get_name() const { return "ShaderGraph"; }
+    bool has_main_screen() const { return false; }
+    virtual void edit(Object *p_node);
+    virtual bool handles(Object *p_node) const;
+    virtual void make_visible(bool p_visible);
 
-	ShaderGraphEditorPlugin(EditorNode *p_node,bool p_2d);
-	~ShaderGraphEditorPlugin();
+    ShaderGraphEditorPlugin(EditorNode *p_node,bool p_2d);
+    ~ShaderGraphEditorPlugin();
 
 };
 #endif
-- 
cgit v1.2.3


From 2a43778793ba67c7edb7d96ab30c4c2a8c145c70 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Mon, 20 Jul 2015 22:15:06 -0300
Subject: Fix tab indent

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 3792 ++++++++++----------
 tools/editor/plugins/shader_graph_editor_plugin.h  |  254 +-
 2 files changed, 2023 insertions(+), 2023 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index a0f7edbd93..6e95432b99 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -37,596 +37,596 @@
 
 void GraphColorRampEdit::_input_event(const InputEvent& p_event) {
 
-        if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
-
-                points.remove(grabbed);
-                grabbed=-1;
-                update();
-                emit_signal("ramp_changed");
-                accept_event();
-        }
-
-        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+	if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
+
+		points.remove(grabbed);
+		grabbed=-1;
+		update();
+		emit_signal("ramp_changed");
+		accept_event();
+	}
+
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
 
-                update();
-                int x = p_event.mouse_button.x;
-                int total_w = get_size().width-get_size().height-3;
-                if (x>total_w+3) {
-
-                        if (grabbed==-1)
-                                return;
-                        Size2 ms = Size2(350, picker->get_combined_minimum_size().height+10);
-                        picker->set_color(points[grabbed].color);
-                        popup->set_pos(get_global_pos()-Size2(0,ms.height));
-                        popup->set_size(ms);
-                        popup->popup();
-                        return;
-                }
-
-
-                float ofs = CLAMP(x/float(total_w),0,1);
-
-                grabbed=-1;
-                grabbing=true;
-                int pos=-1;
-                for(int i=0;i<points.size();i++) {
+		update();
+		int x = p_event.mouse_button.x;
+		int total_w = get_size().width-get_size().height-3;
+		if (x>total_w+3) {
+
+			if (grabbed==-1)
+				return;
+			Size2 ms = Size2(350, picker->get_combined_minimum_size().height+10);
+			picker->set_color(points[grabbed].color);
+			popup->set_pos(get_global_pos()-Size2(0,ms.height));
+			popup->set_size(ms);
+			popup->popup();
+			return;
+		}
+
+
+		float ofs = CLAMP(x/float(total_w),0,1);
+
+		grabbed=-1;
+		grabbing=true;
+		int pos=-1;
+		for(int i=0;i<points.size();i++) {
 
-                        if (ABS(x-points[i].offset*total_w)<4) {
-                                grabbed=i;
-                        }
-                        if (points[i].offset<ofs)
-                                pos=i;
-                }
+			if (ABS(x-points[i].offset*total_w)<4) {
+				grabbed=i;
+			}
+			if (points[i].offset<ofs)
+				pos=i;
+		}
 
-                grabbed_at=ofs;
-                //grab or select
-                if (grabbed!=-1) {
-                        return;
-                }
-                //insert
+		grabbed_at=ofs;
+		//grab or select
+		if (grabbed!=-1) {
+			return;
+		}
+		//insert
 
 
-                Point p;
-                p.offset=ofs;
+		Point p;
+		p.offset=ofs;
 
-                Point prev;
-                Point next;
+		Point prev;
+		Point next;
 
-                if (pos==-1) {
+		if (pos==-1) {
 
-                        prev.color=Color(0,0,0);
-                        prev.offset=0;
-                        if (points.size()) {
-                                next=points[0];
-                        } else {
-                                next.color=Color(1,1,1);
-                                next.offset=1.0;
-                        }
-                } else  {
+			prev.color=Color(0,0,0);
+			prev.offset=0;
+			if (points.size()) {
+				next=points[0];
+			} else {
+				next.color=Color(1,1,1);
+				next.offset=1.0;
+			}
+		} else  {
 
-                        if (pos==points.size()-1) {
-                                next.color=Color(1,1,1);
-                                next.offset=1.0;
-                        } else {
-                                next=points[pos+1];
-                        }
-                        prev=points[pos];
+			if (pos==points.size()-1) {
+				next.color=Color(1,1,1);
+				next.offset=1.0;
+			} else {
+				next=points[pos+1];
+			}
+			prev=points[pos];
 
-                }
+		}
 
-                p.color=prev.color.linear_interpolate(next.color,(p.offset-prev.offset)/(next.offset-prev.offset));
+		p.color=prev.color.linear_interpolate(next.color,(p.offset-prev.offset)/(next.offset-prev.offset));
 
-                points.push_back(p);
-                points.sort();
-                for(int i=0;i<points.size();i++) {
-                        if (points[i].offset==ofs) {
-                                grabbed=i;
-                                break;
-                        }
-                }
+		points.push_back(p);
+		points.sort();
+		for(int i=0;i<points.size();i++) {
+			if (points[i].offset==ofs) {
+				grabbed=i;
+				break;
+			}
+		}
 
-                emit_signal("ramp_changed");
+		emit_signal("ramp_changed");
 
-        }
+	}
 
-        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
 
-                if (grabbing) {
-                        grabbing=false;
-                        emit_signal("ramp_changed");
-                }
-                update();
-        }
+		if (grabbing) {
+			grabbing=false;
+			emit_signal("ramp_changed");
+		}
+		update();
+	}
 
-        if (p_event.type==InputEvent::MOUSE_MOTION && grabbing) {
+	if (p_event.type==InputEvent::MOUSE_MOTION && grabbing) {
 
-                int total_w = get_size().width-get_size().height-3;
+		int total_w = get_size().width-get_size().height-3;
 
-                int x = p_event.mouse_motion.x;
-                float newofs = CLAMP(x/float(total_w),0,1);
+		int x = p_event.mouse_motion.x;
+		float newofs = CLAMP(x/float(total_w),0,1);
 
-                bool valid=true;
-                for(int i=0;i<points.size();i++) {
+		bool valid=true;
+		for(int i=0;i<points.size();i++) {
 
-                        if (points[i].offset==newofs && i!=grabbed) {
-                                valid=false;
-                        }
-                }
+			if (points[i].offset==newofs && i!=grabbed) {
+				valid=false;
+			}
+		}
 
-                if (!valid)
-                        return;
+		if (!valid)
+			return;
 
-                points[grabbed].offset=newofs;
+		points[grabbed].offset=newofs;
 
-                points.sort();
-                for(int i=0;i<points.size();i++) {
-                        if (points[i].offset==newofs) {
-                                grabbed=i;
-                                break;
-                        }
-                }
+		points.sort();
+		for(int i=0;i<points.size();i++) {
+			if (points[i].offset==newofs) {
+				grabbed=i;
+				break;
+			}
+		}
 
-                emit_signal("ramp_changed");
+		emit_signal("ramp_changed");
 
-                update();
-        }
+		update();
+	}
 }
 
 void GraphColorRampEdit::_notification(int p_what){
 
-        if (p_what==NOTIFICATION_ENTER_TREE) {
-                picker->connect("color_changed",this,"_color_changed");
-        }
-        if (p_what==NOTIFICATION_DRAW) {
+	if (p_what==NOTIFICATION_ENTER_TREE) {
+		picker->connect("color_changed",this,"_color_changed");
+	}
+	if (p_what==NOTIFICATION_DRAW) {
 
 
-                Point prev;
-                prev.offset=0;
-                prev.color=Color(0,0,0);
-                int w = get_size().x;
-                int h = get_size().y;
+		Point prev;
+		prev.offset=0;
+		prev.color=Color(0,0,0);
+		int w = get_size().x;
+		int h = get_size().y;
 
-                int total_w = get_size().width-get_size().height-3;
+		int total_w = get_size().width-get_size().height-3;
 
-                for(int i=-1;i<points.size();i++) {
+		for(int i=-1;i<points.size();i++) {
 
-                        Point next;
-                        if (i+1==points.size()) {
-                                next.color=Color(1,1,1);
-                                next.offset=1;
-                        } else {
-                                next=points[i+1];
-                        }
+			Point next;
+			if (i+1==points.size()) {
+				next.color=Color(1,1,1);
+				next.offset=1;
+			} else {
+				next=points[i+1];
+			}
 
-                        if (prev.offset==next.offset) {
-                                prev=next;
-                                continue;
-                        }
+			if (prev.offset==next.offset) {
+				prev=next;
+				continue;
+			}
 
-                        Vector<Vector2> points;
-                        Vector<Color> colors;
-                        points.push_back(Vector2(prev.offset*total_w,h));
-                        points.push_back(Vector2(prev.offset*total_w,0));
-                        points.push_back(Vector2(next.offset*total_w,0));
-                        points.push_back(Vector2(next.offset*total_w,h));
-                        colors.push_back(prev.color);
-                        colors.push_back(prev.color);
-                        colors.push_back(next.color);
-                        colors.push_back(next.color);
-                        draw_primitive(points,colors,Vector<Point2>());
-                        prev=next;
-                }
+			Vector<Vector2> points;
+			Vector<Color> colors;
+			points.push_back(Vector2(prev.offset*total_w,h));
+			points.push_back(Vector2(prev.offset*total_w,0));
+			points.push_back(Vector2(next.offset*total_w,0));
+			points.push_back(Vector2(next.offset*total_w,h));
+			colors.push_back(prev.color);
+			colors.push_back(prev.color);
+			colors.push_back(next.color);
+			colors.push_back(next.color);
+			draw_primitive(points,colors,Vector<Point2>());
+			prev=next;
+		}
 
-                for(int i=0;i<points.size();i++) {
+		for(int i=0;i<points.size();i++) {
 
-                        Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
+			Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
 
-                        draw_line(Vector2(points[i].offset*total_w,0),Vector2(points[i].offset*total_w,h-1),Color(0,0,0,0.7));
-                        draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w-1,h-1),col);
-                        draw_line(Vector2(points[i].offset*total_w+1,h/2),Vector2(points[i].offset*total_w+1,h-1),col);
-                        draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w+1,h/2),col);
-                        draw_line(Vector2(points[i].offset*total_w-1,h-1),Vector2(points[i].offset*total_w+1,h-1),col);
+			draw_line(Vector2(points[i].offset*total_w,0),Vector2(points[i].offset*total_w,h-1),Color(0,0,0,0.7));
+			draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w-1,h-1),col);
+			draw_line(Vector2(points[i].offset*total_w+1,h/2),Vector2(points[i].offset*total_w+1,h-1),col);
+			draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w+1,h/2),col);
+			draw_line(Vector2(points[i].offset*total_w-1,h-1),Vector2(points[i].offset*total_w+1,h-1),col);
 
-                }
+		}
 
-                if (grabbed!=-1) {
+		if (grabbed!=-1) {
 
-                        draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
-                }
+			draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
+		}
 
-                if (has_focus()) {
+		if (has_focus()) {
 
-                        draw_line(Vector2(-1,-1),Vector2(total_w+1,-1),Color(1,1,1,0.6));
-                        draw_line(Vector2(total_w+1,-1),Vector2(total_w+1,h+1),Color(1,1,1,0.6));
-                        draw_line(Vector2(total_w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
-                        draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
-                }
+			draw_line(Vector2(-1,-1),Vector2(total_w+1,-1),Color(1,1,1,0.6));
+			draw_line(Vector2(total_w+1,-1),Vector2(total_w+1,h+1),Color(1,1,1,0.6));
+			draw_line(Vector2(total_w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
+			draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
+		}
 
-        }
+	}
 }
 
 Size2 GraphColorRampEdit::get_minimum_size() const {
 
-        return Vector2(0,16);
+	return Vector2(0,16);
 }
 
 
 void GraphColorRampEdit::_color_changed(const Color& p_color) {
 
-        if (grabbed==-1)
-                return;
-        points[grabbed].color=p_color;
-        update();
-        emit_signal("ramp_changed");
+	if (grabbed==-1)
+		return;
+	points[grabbed].color=p_color;
+	update();
+	emit_signal("ramp_changed");
 
 }
 
 void GraphColorRampEdit::set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors) {
 
-        ERR_FAIL_COND(p_offsets.size()!=p_colors.size());
-        points.clear();
-        for(int i=0;i<p_offsets.size();i++) {
-                Point p;
-                p.offset=p_offsets[i];
-                p.color=p_colors[i];
-                points.push_back(p);
-        }
+	ERR_FAIL_COND(p_offsets.size()!=p_colors.size());
+	points.clear();
+	for(int i=0;i<p_offsets.size();i++) {
+		Point p;
+		p.offset=p_offsets[i];
+		p.color=p_colors[i];
+		points.push_back(p);
+	}
 
-        points.sort();
-        update();
+	points.sort();
+	update();
 }
 
 Vector<float> GraphColorRampEdit::get_offsets() const{
-        Vector<float> ret;
-        for(int i=0;i<points.size();i++)
-                ret.push_back(points[i].offset);
-        return ret;
+	Vector<float> ret;
+	for(int i=0;i<points.size();i++)
+		ret.push_back(points[i].offset);
+	return ret;
 }
 Vector<Color> GraphColorRampEdit::get_colors() const{
 
-        Vector<Color> ret;
-        for(int i=0;i<points.size();i++)
-                ret.push_back(points[i].color);
-        return ret;
+	Vector<Color> ret;
+	for(int i=0;i<points.size();i++)
+		ret.push_back(points[i].color);
+	return ret;
 }
 
 
 void GraphColorRampEdit::_bind_methods(){
 
-        ObjectTypeDB::bind_method(_MD("_input_event"),&GraphColorRampEdit::_input_event);
-        ObjectTypeDB::bind_method(_MD("_color_changed"),&GraphColorRampEdit::_color_changed);
-        ADD_SIGNAL(MethodInfo("ramp_changed"));
+	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphColorRampEdit::_input_event);
+	ObjectTypeDB::bind_method(_MD("_color_changed"),&GraphColorRampEdit::_color_changed);
+	ADD_SIGNAL(MethodInfo("ramp_changed"));
 }
 
 GraphColorRampEdit::GraphColorRampEdit(){
 
-        grabbed=-1;
-        grabbing=false;
-        set_focus_mode(FOCUS_ALL);
+	grabbed=-1;
+	grabbing=false;
+	set_focus_mode(FOCUS_ALL);
 
-        popup = memnew( PopupPanel );
-        picker = memnew( ColorPicker );
-        popup->add_child(picker);
-        popup->set_child_rect(picker);
-        add_child(popup);
+	popup = memnew( PopupPanel );
+	picker = memnew( ColorPicker );
+	popup->add_child(picker);
+	popup->set_child_rect(picker);
+	add_child(popup);
 
 }
 ////////////
 
 void GraphCurveMapEdit::_input_event(const InputEvent& p_event) {
 
-        if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
+	if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
 
-                points.remove(grabbed);
-                grabbed=-1;
-                update();
-                emit_signal("curve_changed");
-                accept_event();
-        }
+		points.remove(grabbed);
+		grabbed=-1;
+		update();
+		emit_signal("curve_changed");
+		accept_event();
+	}
 
-        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
 
-                update();
-                Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
-                p.y=1.0-p.y;
-                grabbed=-1;
-                grabbing=true;
+		update();
+		Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
+		p.y=1.0-p.y;
+		grabbed=-1;
+		grabbing=true;
 
-                for(int i=0;i<points.size();i++) {
+		for(int i=0;i<points.size();i++) {
 
-                        Vector2 ps = p*get_size();
-                        Vector2 pt = Vector2(points[i].offset,points[i].height)*get_size();
-                        if (ps.distance_to(pt)<4) {
-                                grabbed=i;
-                        }
+			Vector2 ps = p*get_size();
+			Vector2 pt = Vector2(points[i].offset,points[i].height)*get_size();
+			if (ps.distance_to(pt)<4) {
+				grabbed=i;
+			}
 
-                }
+		}
 
 
-                //grab or select
-                if (grabbed!=-1) {
-                        return;
-                }
-                //insert
+		//grab or select
+		if (grabbed!=-1) {
+			return;
+		}
+		//insert
 
 
-                Point np;
-                np.offset=p.x;
-                np.height=p.y;
+		Point np;
+		np.offset=p.x;
+		np.height=p.y;
 
-                points.push_back(np);
-                points.sort();
-                for(int i=0;i<points.size();i++) {
-                        if (points[i].offset==p.x && points[i].height==p.y) {
-                                grabbed=i;
-                                break;
-                        }
-                }
+		points.push_back(np);
+		points.sort();
+		for(int i=0;i<points.size();i++) {
+			if (points[i].offset==p.x && points[i].height==p.y) {
+				grabbed=i;
+				break;
+			}
+		}
 
-                emit_signal("curve_changed");
+		emit_signal("curve_changed");
 
-        }
+	}
 
-        if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
 
-                if (grabbing) {
-                        grabbing=false;
-                        emit_signal("curve_changed");
-                }
-                update();
-        }
+		if (grabbing) {
+			grabbing=false;
+			emit_signal("curve_changed");
+		}
+		update();
+	}
 
-        if (p_event.type==InputEvent::MOUSE_MOTION && grabbing  && grabbed != -1) {
+	if (p_event.type==InputEvent::MOUSE_MOTION && grabbing  && grabbed != -1) {
 
-                Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
-                p.y=1.0-p.y;
+		Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
+		p.y=1.0-p.y;
 
-                p.x = CLAMP(p.x,0.0,1.0);
-                p.y = CLAMP(p.y,0.0,1.0);
+		p.x = CLAMP(p.x,0.0,1.0);
+		p.y = CLAMP(p.y,0.0,1.0);
 
-                bool valid=true;
+		bool valid=true;
 
-                for(int i=0;i<points.size();i++) {
+		for(int i=0;i<points.size();i++) {
 
-                        if (points[i].offset==p.x && points[i].height==p.y && i!=grabbed) {
-                                valid=false;
-                        }
-                }
+			if (points[i].offset==p.x && points[i].height==p.y && i!=grabbed) {
+				valid=false;
+			}
+		}
 
-                if (!valid)
-                        return;
+		if (!valid)
+			return;
 
-                points[grabbed].offset=p.x;
-                points[grabbed].height=p.y;
+		points[grabbed].offset=p.x;
+		points[grabbed].height=p.y;
 
-                points.sort();
-                for(int i=0;i<points.size();i++) {
-                        if (points[i].offset==p.x && points[i].height==p.y) {
-                                grabbed=i;
-                                break;
-                        }
-                }
+		points.sort();
+		for(int i=0;i<points.size();i++) {
+			if (points[i].offset==p.x && points[i].height==p.y) {
+				grabbed=i;
+				break;
+			}
+		}
 
-                emit_signal("curve_changed");
+		emit_signal("curve_changed");
 
-                update();
-        }
+		update();
+	}
 }
 
 void GraphCurveMapEdit::_plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d) {
 
-        float geometry[4][4];
-        float tmp1[4][4];
-        float tmp2[4][4];
-        float deltas[4][4];
-        double x, dx, dx2, dx3;
-        double y, dy, dy2, dy3;
-        double d, d2, d3;
-        int lastx, lasty;
-        int newx, newy;
-        int ntimes;
-        int i,j;
-
-        int xmax=get_size().x;
-        int ymax=get_size().y;
-
-        /* construct the geometry matrix from the segment */
-        for (i = 0; i < 4; i++)	{
-                geometry[i][2] = 0;
-                geometry[i][3] = 0;
-        }
-
-        geometry[0][0] = (p_a[0] * xmax);
-        geometry[1][0] = (p_b[0] * xmax);
-        geometry[2][0] = (p_c[0] * xmax);
-        geometry[3][0] = (p_d[0] * xmax);
-
-        geometry[0][1] = (p_a[1] * ymax);
-        geometry[1][1] = (p_b[1] * ymax);
-        geometry[2][1] = (p_c[1] * ymax);
-        geometry[3][1] = (p_d[1] * ymax);
-
-        /* subdivide the curve ntimes (1000) times */
-        ntimes = 4 * xmax;
-        /* ntimes can be adjusted to give a finer or coarser curve */
-        d = 1.0 / ntimes;
-        d2 = d * d;
-        d3 = d * d * d;
-
-        /* construct a temporary matrix for determining the forward differencing deltas */
-        tmp2[0][0] = 0;		 tmp2[0][1] = 0;		 tmp2[0][2] = 0;		tmp2[0][3] = 1;
-        tmp2[1][0] = d3;		tmp2[1][1] = d2;		tmp2[1][2] = d;		tmp2[1][3] = 0;
-        tmp2[2][0] = 6*d3;  tmp2[2][1] = 2*d2;  tmp2[2][2] = 0;		tmp2[2][3] = 0;
-        tmp2[3][0] = 6*d3;  tmp2[3][1] = 0;		 tmp2[3][2] = 0;		tmp2[3][3] = 0;
-
-        /* compose the basis and geometry matrices */
-
-        static const float CR_basis[4][4] =
-        {
-          { -0.5,  1.5, -1.5,  0.5 },
-          {  1.0, -2.5,  2.0, -0.5 },
-          { -0.5,  0.0,  0.5,  0.0 },
-          {  0.0,  1.0,  0.0,  0.0 },
-        };
-
-        for (i = 0; i < 4; i++)
-                {
-                  for (j = 0; j < 4; j++)
-                {
-                  tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] +
-                                  CR_basis[i][1] * geometry[1][j] +
-                                  CR_basis[i][2] * geometry[2][j] +
-                                  CR_basis[i][3] * geometry[3][j]);
-                }
-                }
-        /* compose the above results to get the deltas matrix */
-
-        for (i = 0; i < 4; i++)
-                {
-                  for (j = 0; j < 4; j++)
-                {
-                  deltas[i][j] = (tmp2[i][0] * tmp1[0][j] +
-                                  tmp2[i][1] * tmp1[1][j] +
-                                  tmp2[i][2] * tmp1[2][j] +
-                                  tmp2[i][3] * tmp1[3][j]);
-                }
-                }
-
-
-        /* extract the x deltas */
-        x = deltas[0][0];
-        dx = deltas[1][0];
-        dx2 = deltas[2][0];
-        dx3 = deltas[3][0];
-
-        /* extract the y deltas */
-        y = deltas[0][1];
-        dy = deltas[1][1];
-        dy2 = deltas[2][1];
-        dy3 = deltas[3][1];
-
-
-        lastx = CLAMP (x, 0, xmax);
-        lasty = CLAMP (y, 0, ymax);
-
-/*	if (fix255)
-        {
-                cd->curve[cd->outline][lastx] = lasty;
-        }
-        else
-        {
-                cd->curve_ptr[cd->outline][lastx] = lasty;
-                if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax);
-        }
+	float geometry[4][4];
+	float tmp1[4][4];
+	float tmp2[4][4];
+	float deltas[4][4];
+	double x, dx, dx2, dx3;
+	double y, dy, dy2, dy3;
+	double d, d2, d3;
+	int lastx, lasty;
+	int newx, newy;
+	int ntimes;
+	int i,j;
+
+	int xmax=get_size().x;
+	int ymax=get_size().y;
+
+	/* construct the geometry matrix from the segment */
+	for (i = 0; i < 4; i++)	{
+		geometry[i][2] = 0;
+		geometry[i][3] = 0;
+	}
+
+	geometry[0][0] = (p_a[0] * xmax);
+	geometry[1][0] = (p_b[0] * xmax);
+	geometry[2][0] = (p_c[0] * xmax);
+	geometry[3][0] = (p_d[0] * xmax);
+
+	geometry[0][1] = (p_a[1] * ymax);
+	geometry[1][1] = (p_b[1] * ymax);
+	geometry[2][1] = (p_c[1] * ymax);
+	geometry[3][1] = (p_d[1] * ymax);
+
+	/* subdivide the curve ntimes (1000) times */
+	ntimes = 4 * xmax;
+	/* ntimes can be adjusted to give a finer or coarser curve */
+	d = 1.0 / ntimes;
+	d2 = d * d;
+	d3 = d * d * d;
+
+	/* construct a temporary matrix for determining the forward differencing deltas */
+	tmp2[0][0] = 0;		 tmp2[0][1] = 0;		 tmp2[0][2] = 0;		tmp2[0][3] = 1;
+	tmp2[1][0] = d3;		tmp2[1][1] = d2;		tmp2[1][2] = d;		tmp2[1][3] = 0;
+	tmp2[2][0] = 6*d3;  tmp2[2][1] = 2*d2;  tmp2[2][2] = 0;		tmp2[2][3] = 0;
+	tmp2[3][0] = 6*d3;  tmp2[3][1] = 0;		 tmp2[3][2] = 0;		tmp2[3][3] = 0;
+
+	/* compose the basis and geometry matrices */
+
+	static const float CR_basis[4][4] =
+	{
+		{ -0.5,  1.5, -1.5,  0.5 },
+		{  1.0, -2.5,  2.0, -0.5 },
+		{ -0.5,  0.0,  0.5,  0.0 },
+		{  0.0,  1.0,  0.0,  0.0 },
+	};
+
+	for (i = 0; i < 4; i++)
+	{
+		for (j = 0; j < 4; j++)
+		{
+			tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] +
+					CR_basis[i][1] * geometry[1][j] +
+					CR_basis[i][2] * geometry[2][j] +
+					CR_basis[i][3] * geometry[3][j]);
+		}
+	}
+	/* compose the above results to get the deltas matrix */
+
+	for (i = 0; i < 4; i++)
+	{
+		for (j = 0; j < 4; j++)
+		{
+			deltas[i][j] = (tmp2[i][0] * tmp1[0][j] +
+					tmp2[i][1] * tmp1[1][j] +
+					tmp2[i][2] * tmp1[2][j] +
+					tmp2[i][3] * tmp1[3][j]);
+		}
+	}
+
+
+	/* extract the x deltas */
+	x = deltas[0][0];
+	dx = deltas[1][0];
+	dx2 = deltas[2][0];
+	dx3 = deltas[3][0];
+
+	/* extract the y deltas */
+	y = deltas[0][1];
+	dy = deltas[1][1];
+	dy2 = deltas[2][1];
+	dy3 = deltas[3][1];
+
+
+	lastx = CLAMP (x, 0, xmax);
+	lasty = CLAMP (y, 0, ymax);
+
+	/*	if (fix255)
+		{
+				cd->curve[cd->outline][lastx] = lasty;
+		}
+		else
+		{
+				cd->curve_ptr[cd->outline][lastx] = lasty;
+				if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax);
+		}
 */
-        /* loop over the curve */
-        for (i = 0; i < ntimes; i++)
-        {
-                /* increment the x values */
-                x += dx;
-                dx += dx2;
-                dx2 += dx3;
-
-                /* increment the y values */
-                y += dy;
-                dy += dy2;
-                dy2 += dy3;
-
-                newx = CLAMP ((Math::round (x)), 0, xmax);
-                newy = CLAMP ((Math::round (y)), 0, ymax);
-
-                /* if this point is different than the last one...then draw it */
-                if ((lastx != newx) || (lasty != newy))
-                {
+	/* loop over the curve */
+	for (i = 0; i < ntimes; i++)
+	{
+		/* increment the x values */
+		x += dx;
+		dx += dx2;
+		dx2 += dx3;
+
+		/* increment the y values */
+		y += dy;
+		dy += dy2;
+		dy2 += dy3;
+
+		newx = CLAMP ((Math::round (x)), 0, xmax);
+		newy = CLAMP ((Math::round (y)), 0, ymax);
+
+		/* if this point is different than the last one...then draw it */
+		if ((lastx != newx) || (lasty != newy))
+		{
 #if 0
-                        if(fix255)
-                        {
-                                /* use fixed array size (for the curve graph) */
-                                cd->curve[cd->outline][newx] = newy;
-                        }
-                        else
-                        {
-                                /* use dynamic allocated curve_ptr (for the real curve) */
-                                cd->curve_ptr[cd->outline][newx] = newy;
-
-                                if(gb_debug) printf("outline: %d  cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy);
-                        }
+			if(fix255)
+			{
+				/* use fixed array size (for the curve graph) */
+				cd->curve[cd->outline][newx] = newy;
+			}
+			else
+			{
+				/* use dynamic allocated curve_ptr (for the real curve) */
+				cd->curve_ptr[cd->outline][newx] = newy;
+
+				if(gb_debug) printf("outline: %d  cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy);
+			}
 #endif
-                        draw_line(Vector2(lastx,ymax-lasty),Vector2(newx,ymax-newy),Color(0.8,0.8,0.8,0.8),2.0);
-                }
+			draw_line(Vector2(lastx,ymax-lasty),Vector2(newx,ymax-newy),Color(0.8,0.8,0.8,0.8),2.0);
+		}
 
-                lastx = newx;
-                lasty = newy;
-        }
+		lastx = newx;
+		lasty = newy;
+	}
 }
 
 
 void GraphCurveMapEdit::_notification(int p_what){
 
-        if (p_what==NOTIFICATION_DRAW) {
+	if (p_what==NOTIFICATION_DRAW) {
 
-                draw_style_box(get_stylebox("bg","Tree"),Rect2(Point2(),get_size()));
+		draw_style_box(get_stylebox("bg","Tree"),Rect2(Point2(),get_size()));
 
-                int w = get_size().x;
-                int h = get_size().y;
+		int w = get_size().x;
+		int h = get_size().y;
 
-                Vector2 prev=Vector2(0,0);
-                Vector2 prev2=Vector2(0,0);
+		Vector2 prev=Vector2(0,0);
+		Vector2 prev2=Vector2(0,0);
 
-                for(int i=-1;i<points.size();i++) {
+		for(int i=-1;i<points.size();i++) {
 
-                        Vector2 next;
-                        Vector2 next2;
-                        if (i+1>=points.size()) {
-                                next=Vector2(1,1);
-                        } else {
-                                next=Vector2(points[i+1].offset,points[i+1].height);
-                        }
+			Vector2 next;
+			Vector2 next2;
+			if (i+1>=points.size()) {
+				next=Vector2(1,1);
+			} else {
+				next=Vector2(points[i+1].offset,points[i+1].height);
+			}
 
-                        if (i+2>=points.size()) {
-                                next2=Vector2(1,1);
-                        } else {
-                                next2=Vector2(points[i+2].offset,points[i+2].height);
-                        }
+			if (i+2>=points.size()) {
+				next2=Vector2(1,1);
+			} else {
+				next2=Vector2(points[i+2].offset,points[i+2].height);
+			}
 
-                        /*if (i==-1 && prev.offset==next.offset) {
-                                prev=next;
-                                continue;
-                        }*/
+			/*if (i==-1 && prev.offset==next.offset) {
+								prev=next;
+								continue;
+						}*/
 
-                        _plot_curve(prev2,prev,next,next2);
+			_plot_curve(prev2,prev,next,next2);
 
-                        prev2=prev;
-                        prev=next;
-                }
+			prev2=prev;
+			prev=next;
+		}
 
-                for(int i=0;i<points.size();i++) {
+		for(int i=0;i<points.size();i++) {
 
-                        Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
+			Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
 
 
-                        draw_rect(Rect2( Vector2(points[i].offset,1.0-points[i].height)*get_size()-Vector2(2,2),Vector2(5,5)),col);
-                }
+			draw_rect(Rect2( Vector2(points[i].offset,1.0-points[i].height)*get_size()-Vector2(2,2),Vector2(5,5)),col);
+		}
 
-/*		if (grabbed!=-1) {
+		/*		if (grabbed!=-1) {
 
-                        draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
-                }
+						draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
+				}
 */
-                if (has_focus()) {
+		if (has_focus()) {
 
-                        draw_line(Vector2(-1,-1),Vector2(w+1,-1),Color(1,1,1,0.6));
-                        draw_line(Vector2(w+1,-1),Vector2(w+1,h+1),Color(1,1,1,0.6));
-                        draw_line(Vector2(w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
-                        draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
-                }
+			draw_line(Vector2(-1,-1),Vector2(w+1,-1),Color(1,1,1,0.6));
+			draw_line(Vector2(w+1,-1),Vector2(w+1,h+1),Color(1,1,1,0.6));
+			draw_line(Vector2(w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
+			draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
+		}
 
-        }
+	}
 }
 
 Size2 GraphCurveMapEdit::get_minimum_size() const {
 
-        return Vector2(64,64);
+	return Vector2(64,64);
 }
 
 
@@ -634,36 +634,36 @@ Size2 GraphCurveMapEdit::get_minimum_size() const {
 void GraphCurveMapEdit::set_points(const Vector<Vector2>& p_points) {
 
 
-        points.clear();
-        for(int i=0;i<p_points.size();i++) {
-                Point p;
-                p.offset=p_points[i].x;
-                p.height=p_points[i].y;
-                points.push_back(p);
-        }
+	points.clear();
+	for(int i=0;i<p_points.size();i++) {
+		Point p;
+		p.offset=p_points[i].x;
+		p.height=p_points[i].y;
+		points.push_back(p);
+	}
 
-        points.sort();
-        update();
+	points.sort();
+	update();
 }
 
 Vector<Vector2> GraphCurveMapEdit::get_points() const {
-        Vector<Vector2> ret;
-        for(int i=0;i<points.size();i++)
-                ret.push_back(Vector2(points[i].offset,points[i].height));
-        return ret;
+	Vector<Vector2> ret;
+	for(int i=0;i<points.size();i++)
+		ret.push_back(Vector2(points[i].offset,points[i].height));
+	return ret;
 }
 
 void GraphCurveMapEdit::_bind_methods(){
 
-        ObjectTypeDB::bind_method(_MD("_input_event"),&GraphCurveMapEdit::_input_event);
-        ADD_SIGNAL(MethodInfo("curve_changed"));
+	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphCurveMapEdit::_input_event);
+	ADD_SIGNAL(MethodInfo("curve_changed"));
 }
 
 GraphCurveMapEdit::GraphCurveMapEdit(){
 
-        grabbed=-1;
-        grabbing=false;
-        set_focus_mode(FOCUS_ALL);
+	grabbed=-1;
+	grabbing=false;
+	set_focus_mode(FOCUS_ALL);
 
 }
 
@@ -672,201 +672,201 @@ GraphCurveMapEdit::GraphCurveMapEdit(){
 ///
 void ShaderGraphView::_scalar_const_changed(double p_value,int p_id) {
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Scalar Constant",true);
-        ur->add_do_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,p_value);
-        ur->add_undo_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,graph->scalar_const_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Scalar Constant",true);
+	ur->add_do_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,p_value);
+	ur->add_undo_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,graph->scalar_const_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 
 void ShaderGraphView::_vec_const_changed(double p_value, int p_id,Array p_arr){
 
-        Vector3 val;
-        for(int i=0;i<p_arr.size();i++) {
-                val[i]=p_arr[i].call("get_val");
-        }
+	Vector3 val;
+	for(int i=0;i<p_arr.size();i++) {
+		val[i]=p_arr[i].call("get_val");
+	}
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Vec Constant",true);
-        ur->add_do_method(graph.ptr(),"vec_const_node_set_value",type,p_id,val);
-        ur->add_undo_method(graph.ptr(),"vec_const_node_set_value",type,p_id,graph->vec_const_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Vec Constant",true);
+	ur->add_do_method(graph.ptr(),"vec_const_node_set_value",type,p_id,val);
+	ur->add_undo_method(graph.ptr(),"vec_const_node_set_value",type,p_id,graph->vec_const_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_rgb_const_changed(const Color& p_color, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change RGB Constant",true);
-        ur->add_do_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,p_color);
-        ur->add_undo_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,graph->rgb_const_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change RGB Constant",true);
+	ur->add_do_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,p_color);
+	ur->add_undo_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,graph->rgb_const_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_scalar_op_changed(int p_op, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Scalar Operator");
-        ur->add_do_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,p_op);
-        ur->add_undo_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,graph->scalar_op_node_get_op(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Scalar Operator");
+	ur->add_do_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,p_op);
+	ur->add_undo_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,graph->scalar_op_node_get_op(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_vec_op_changed(int p_op, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Vec Operator");
-        ur->add_do_method(graph.ptr(),"vec_op_node_set_op",type,p_id,p_op);
-        ur->add_undo_method(graph.ptr(),"vec_op_node_set_op",type,p_id,graph->vec_op_node_get_op(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Vec Operator");
+	ur->add_do_method(graph.ptr(),"vec_op_node_set_op",type,p_id,p_op);
+	ur->add_undo_method(graph.ptr(),"vec_op_node_set_op",type,p_id,graph->vec_op_node_get_op(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 void ShaderGraphView::_vec_scalar_op_changed(int p_op, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change VecxScalar Operator");
-        ur->add_do_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,p_op);
-        ur->add_undo_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,graph->vec_scalar_op_node_get_op(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change VecxScalar Operator");
+	ur->add_do_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,p_op);
+	ur->add_undo_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,graph->vec_scalar_op_node_get_op(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_rgb_op_changed(int p_op, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change RGB Operator");
-        ur->add_do_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,p_op);
-        ur->add_undo_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,graph->rgb_op_node_get_op(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change RGB Operator");
+	ur->add_do_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,p_op);
+	ur->add_undo_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,graph->rgb_op_node_get_op(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 void ShaderGraphView::_xform_inv_rev_changed(bool p_enabled, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Toggle Rot Only");
-        ur->add_do_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,p_enabled);
-        ur->add_undo_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,graph->xform_vec_mult_node_get_no_translation(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Toggle Rot Only");
+	ur->add_do_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,p_enabled);
+	ur->add_undo_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,graph->xform_vec_mult_node_get_no_translation(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 void ShaderGraphView::_scalar_func_changed(int p_func, int p_id){
 
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Scalar Function");
-        ur->add_do_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,p_func);
-        ur->add_undo_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,graph->scalar_func_node_get_function(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Scalar Function");
+	ur->add_do_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,p_func);
+	ur->add_undo_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,graph->scalar_func_node_get_function(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 void ShaderGraphView::_vec_func_changed(int p_func, int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Vec Function");
-        ur->add_do_method(graph.ptr(),"vec_func_node_set_function",type,p_id,p_func);
-        ur->add_undo_method(graph.ptr(),"vec_func_node_set_function",type,p_id,graph->vec_func_node_get_function(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Vec Function");
+	ur->add_do_method(graph.ptr(),"vec_func_node_set_function",type,p_id,p_func);
+	ur->add_undo_method(graph.ptr(),"vec_func_node_set_function",type,p_id,graph->vec_func_node_get_function(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_scalar_input_changed(double p_value,int p_id){
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Scalar Uniform",true);
-        ur->add_do_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,p_value);
-        ur->add_undo_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,graph->scalar_input_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Scalar Uniform",true);
+	ur->add_do_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,p_value);
+	ur->add_undo_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,graph->scalar_input_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_vec_input_changed(double p_value, int p_id,Array p_arr){
 
-        Vector3 val;
-        for(int i=0;i<p_arr.size();i++) {
-                val[i]=p_arr[i].call("get_val");
-        }
+	Vector3 val;
+	for(int i=0;i<p_arr.size();i++) {
+		val[i]=p_arr[i].call("get_val");
+	}
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Vec Uniform",true);
-        ur->add_do_method(graph.ptr(),"vec_input_node_set_value",type,p_id,val);
-        ur->add_undo_method(graph.ptr(),"vec_input_node_set_value",type,p_id,graph->vec_input_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Vec Uniform",true);
+	ur->add_do_method(graph.ptr(),"vec_input_node_set_value",type,p_id,val);
+	ur->add_undo_method(graph.ptr(),"vec_input_node_set_value",type,p_id,graph->vec_input_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 void ShaderGraphView::_xform_input_changed(int p_id, Node *p_button){
 
 
-        ToolButton *tb = p_button->cast_to<ToolButton>();
-        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-        ped_popup->set_size(tb->get_size());
-        edited_id=p_id;
-        ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
-        ped_popup->popup();
+	ToolButton *tb = p_button->cast_to<ToolButton>();
+	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+	ped_popup->set_size(tb->get_size());
+	edited_id=p_id;
+	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
+	ped_popup->popup();
 
 }
 void ShaderGraphView::_xform_const_changed(int p_id, Node *p_button){
 
-        ToolButton *tb = p_button->cast_to<ToolButton>();
-        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-        ped_popup->set_size(tb->get_size());
-        edited_id=p_id;
-        ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
-        ped_popup->popup();
+	ToolButton *tb = p_button->cast_to<ToolButton>();
+	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+	ped_popup->set_size(tb->get_size());
+	edited_id=p_id;
+	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
+	ped_popup->popup();
 
 }
 
 void ShaderGraphView::_rgb_input_changed(const Color& p_color, int p_id){
 
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change RGB Uniform",true);
-        ur->add_do_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,p_color);
-        ur->add_undo_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,graph->rgb_input_node_get_value(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change RGB Uniform",true);
+	ur->add_do_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,p_color);
+	ur->add_undo_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,graph->rgb_input_node_get_value(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 void ShaderGraphView::_tex_input_change(int p_id, Node *p_button){
 
@@ -879,180 +879,180 @@ void ShaderGraphView::_cube_input_change(int p_id){
 
 void ShaderGraphView::_variant_edited() {
 
-        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
+	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
 
-                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-                ur->create_action("Change XForm Uniform");
-                ur->add_do_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,ped_popup->get_variant());
-                ur->add_undo_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,graph->xform_const_node_get_value(type,edited_id));
-                ur->add_do_method(this,"_update_graph");
-                ur->add_undo_method(this,"_update_graph");
-                ur->commit_action();
-        }
+		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+		ur->create_action("Change XForm Uniform");
+		ur->add_do_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,ped_popup->get_variant());
+		ur->add_undo_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,graph->xform_const_node_get_value(type,edited_id));
+		ur->add_do_method(this,"_update_graph");
+		ur->add_undo_method(this,"_update_graph");
+		ur->commit_action();
+	}
 
 
-        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_INPUT) {
+	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_INPUT) {
 
-                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-                ur->create_action("Change XForm Uniform");
-                ur->add_do_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,ped_popup->get_variant());
-                ur->add_undo_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,graph->xform_input_node_get_value(type,edited_id));
-                ur->add_do_method(this,"_update_graph");
-                ur->add_undo_method(this,"_update_graph");
-                ur->commit_action();
-        }
+		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+		ur->create_action("Change XForm Uniform");
+		ur->add_do_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,ped_popup->get_variant());
+		ur->add_undo_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,graph->xform_input_node_get_value(type,edited_id));
+		ur->add_do_method(this,"_update_graph");
+		ur->add_undo_method(this,"_update_graph");
+		ur->commit_action();
+	}
 
-        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_TEXTURE_INPUT) {
+	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_TEXTURE_INPUT) {
 
-                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-                ur->create_action("Change Texture Uniform");
-                ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,ped_popup->get_variant());
-                ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,graph->texture_input_node_get_value(type,edited_id));
-                ur->add_do_method(this,"_update_graph");
-                ur->add_undo_method(this,"_update_graph");
-                ur->commit_action();
-        }
+		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+		ur->create_action("Change Texture Uniform");
+		ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,ped_popup->get_variant());
+		ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,graph->texture_input_node_get_value(type,edited_id));
+		ur->add_do_method(this,"_update_graph");
+		ur->add_undo_method(this,"_update_graph");
+		ur->commit_action();
+	}
 
-        if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_CUBEMAP_INPUT) {
+	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_CUBEMAP_INPUT) {
 
-                UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-                ur->create_action("Change Cubemap Uniform");
-                ur->add_do_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,ped_popup->get_variant());
-                ur->add_undo_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,graph->cubemap_input_node_get_value(type,edited_id));
-                ur->add_do_method(this,"_update_graph");
-                ur->add_undo_method(this,"_update_graph");
-                ur->commit_action();
-        }
+		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+		ur->create_action("Change Cubemap Uniform");
+		ur->add_do_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,ped_popup->get_variant());
+		ur->add_undo_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,graph->cubemap_input_node_get_value(type,edited_id));
+		ur->add_do_method(this,"_update_graph");
+		ur->add_undo_method(this,"_update_graph");
+		ur->commit_action();
+	}
 
 }
 
 void ShaderGraphView::_comment_edited(int p_id,Node* p_button) {
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        TextEdit *te=p_button->cast_to<TextEdit>();
-        ur->create_action("Change Comment",true);
-        ur->add_do_method(graph.ptr(),"comment_node_set_text",type,p_id,te->get_text());
-        ur->add_undo_method(graph.ptr(),"comment_node_set_text",type,p_id,graph->comment_node_get_text(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	TextEdit *te=p_button->cast_to<TextEdit>();
+	ur->create_action("Change Comment",true);
+	ur->add_do_method(graph.ptr(),"comment_node_set_text",type,p_id,te->get_text());
+	ur->add_undo_method(graph.ptr(),"comment_node_set_text",type,p_id,graph->comment_node_get_text(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 
 }
 
 void ShaderGraphView::_color_ramp_changed(int p_id,Node* p_ramp) {
 
-        GraphColorRampEdit *cr=p_ramp->cast_to<GraphColorRampEdit>();
+	GraphColorRampEdit *cr=p_ramp->cast_to<GraphColorRampEdit>();
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
 
-        Vector<float> offsets=cr->get_offsets();
-        Vector<Color> colors=cr->get_colors();
+	Vector<float> offsets=cr->get_offsets();
+	Vector<Color> colors=cr->get_colors();
 
-        DVector<float> new_offsets;
-        DVector<Color> new_colors;
-        {
-                new_offsets.resize(offsets.size());
-                new_colors.resize(colors.size());
-                DVector<float>::Write ow=new_offsets.write();
-                DVector<Color>::Write cw=new_colors.write();
-                for(int i=0;i<new_offsets.size();i++) {
-                        ow[i]=offsets[i];
-                        cw[i]=colors[i];
-                }
+	DVector<float> new_offsets;
+	DVector<Color> new_colors;
+	{
+		new_offsets.resize(offsets.size());
+		new_colors.resize(colors.size());
+		DVector<float>::Write ow=new_offsets.write();
+		DVector<Color>::Write cw=new_colors.write();
+		for(int i=0;i<new_offsets.size();i++) {
+			ow[i]=offsets[i];
+			cw[i]=colors[i];
+		}
 
-        }
+	}
 
 
-        DVector<float> old_offsets=graph->color_ramp_node_get_offsets(type,p_id);
-        DVector<Color> old_colors=graph->color_ramp_node_get_colors(type,p_id);
+	DVector<float> old_offsets=graph->color_ramp_node_get_offsets(type,p_id);
+	DVector<Color> old_colors=graph->color_ramp_node_get_colors(type,p_id);
 
-        if (old_offsets.size()!=new_offsets.size())
-                ur->create_action("Add/Remove to Color Ramp");
-        else
-                ur->create_action("Modify Color Ramp",true);
+	if (old_offsets.size()!=new_offsets.size())
+		ur->create_action("Add/Remove to Color Ramp");
+	else
+		ur->create_action("Modify Color Ramp",true);
 
-        ur->add_do_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,new_colors,new_offsets);
-        ur->add_undo_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,old_colors,old_offsets);
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	ur->add_do_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,new_colors,new_offsets);
+	ur->add_undo_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,old_colors,old_offsets);
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 
 void ShaderGraphView::_curve_changed(int p_id,Node* p_curve) {
 
-        GraphCurveMapEdit *cr=p_curve->cast_to<GraphCurveMapEdit>();
+	GraphCurveMapEdit *cr=p_curve->cast_to<GraphCurveMapEdit>();
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
 
-        Vector<Point2> points=cr->get_points();
+	Vector<Point2> points=cr->get_points();
 
-        DVector<Vector2> new_points;
-        {
-                new_points.resize(points.size());
-                DVector<Vector2>::Write ow=new_points.write();
-                for(int i=0;i<new_points.size();i++) {
-                        ow[i]=points[i];
-                }
+	DVector<Vector2> new_points;
+	{
+		new_points.resize(points.size());
+		DVector<Vector2>::Write ow=new_points.write();
+		for(int i=0;i<new_points.size();i++) {
+			ow[i]=points[i];
+		}
 
-        }
+	}
 
 
-        DVector<Vector2> old_points=graph->curve_map_node_get_points(type,p_id);
+	DVector<Vector2> old_points=graph->curve_map_node_get_points(type,p_id);
 
-        if (old_points.size()!=new_points.size())
-                ur->create_action("Add/Remove to Curve Map");
-        else
-                ur->create_action("Modify Curve Map",true);
+	if (old_points.size()!=new_points.size())
+		ur->create_action("Add/Remove to Curve Map");
+	else
+		ur->create_action("Modify Curve Map",true);
 
-        ur->add_do_method(graph.ptr(),"curve_map_node_set_points",type,p_id,new_points);
-        ur->add_undo_method(graph.ptr(),"curve_map_node_set_points",type,p_id,old_points);
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
+	ur->add_do_method(graph.ptr(),"curve_map_node_set_points",type,p_id,new_points);
+	ur->add_undo_method(graph.ptr(),"curve_map_node_set_points",type,p_id,old_points);
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
 }
 
 
 void ShaderGraphView::_input_name_changed(const String& p_name, int p_id, Node *p_line_edit) {
 
-        LineEdit *le=p_line_edit->cast_to<LineEdit>();
-        ERR_FAIL_COND(!le);
+	LineEdit *le=p_line_edit->cast_to<LineEdit>();
+	ERR_FAIL_COND(!le);
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Change Input Name");
-        ur->add_do_method(graph.ptr(),"input_node_set_name",type,p_id,p_name);
-        ur->add_undo_method(graph.ptr(),"input_node_set_name",type,p_id,graph->input_node_get_name(type,p_id));
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        block_update=true;
-        ur->commit_action();
-        block_update=false;
-        le->set_text(graph->input_node_get_name(type,p_id));
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Change Input Name");
+	ur->add_do_method(graph.ptr(),"input_node_set_name",type,p_id,p_name);
+	ur->add_undo_method(graph.ptr(),"input_node_set_name",type,p_id,graph->input_node_get_name(type,p_id));
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	block_update=true;
+	ur->commit_action();
+	block_update=false;
+	le->set_text(graph->input_node_get_name(type,p_id));
 }
 
 void ShaderGraphView::_tex_edited(int p_id,Node* p_button) {
 
-        ToolButton *tb = p_button->cast_to<ToolButton>();
-        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-        ped_popup->set_size(tb->get_size());
-        edited_id=p_id;
-        ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
+	ToolButton *tb = p_button->cast_to<ToolButton>();
+	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+	ped_popup->set_size(tb->get_size());
+	edited_id=p_id;
+	ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
 }
 
 void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
 
-        ToolButton *tb = p_button->cast_to<ToolButton>();
-        ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
-        ped_popup->set_size(tb->get_size());
-        edited_id=p_id;
-        ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
+	ToolButton *tb = p_button->cast_to<ToolButton>();
+	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+	ped_popup->set_size(tb->get_size());
+	edited_id=p_id;
+	ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
 }
 
 
@@ -1061,994 +1061,994 @@ void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
 
 void ShaderGraphView::_connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
-        int from_idx=-1;
-        int to_idx=-1;
-        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+	int from_idx=-1;
+	int to_idx=-1;
+	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-                if (p_from==E->get()->get_name())
-                        from_idx=E->key();
-                if (p_to==E->get()->get_name())
-                        to_idx=E->key();
-        }
+		if (p_from==E->get()->get_name())
+			from_idx=E->key();
+		if (p_to==E->get()->get_name())
+			to_idx=E->key();
+	}
 
-        ERR_FAIL_COND(from_idx==-1);
-        ERR_FAIL_COND(to_idx==-1);
+	ERR_FAIL_COND(from_idx==-1);
+	ERR_FAIL_COND(to_idx==-1);
 
-        ur->create_action("Connect Graph Nodes");
+	ur->create_action("Connect Graph Nodes");
 
-        List<ShaderGraph::Connection> conns;
+	List<ShaderGraph::Connection> conns;
 
-        graph->get_node_connections(type,&conns);
-        //disconnect/reconnect dependencies
-        ur->add_undo_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-        for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
+	graph->get_node_connections(type,&conns);
+	//disconnect/reconnect dependencies
+	ur->add_undo_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+	for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
 
-                if (E->get().dst_id==to_idx && E->get().dst_slot==p_to_slot) {
-                        ur->add_do_method(graph.ptr(),"disconnect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-                        ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-                }
-        }
-        ur->add_do_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        ur->commit_action();
+		if (E->get().dst_id==to_idx && E->get().dst_slot==p_to_slot) {
+			ur->add_do_method(graph.ptr(),"disconnect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+			ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+		}
+	}
+	ur->add_do_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
 
 
 }
 
 void ShaderGraphView::_disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
 
-        int from_idx=-1;
-        int to_idx=-1;
-        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+	int from_idx=-1;
+	int to_idx=-1;
+	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-                if (p_from==E->get()->get_name())
-                        from_idx=E->key();
-                if (p_to==E->get()->get_name())
-                        to_idx=E->key();
-        }
+		if (p_from==E->get()->get_name())
+			from_idx=E->key();
+		if (p_to==E->get()->get_name())
+			to_idx=E->key();
+	}
 
-        ERR_FAIL_COND(from_idx==-1);
-        ERR_FAIL_COND(to_idx==-1);
+	ERR_FAIL_COND(from_idx==-1);
+	ERR_FAIL_COND(to_idx==-1);
 
-        if (!graph->is_node_connected(type,from_idx,p_from_slot,to_idx,p_to_slot))
-                return; //nothing to disconnect
+	if (!graph->is_node_connected(type,from_idx,p_from_slot,to_idx,p_to_slot))
+		return; //nothing to disconnect
 
-        ur->create_action("Disconnect Graph Nodes");
+	ur->create_action("Disconnect Graph Nodes");
 
-        List<ShaderGraph::Connection> conns;
+	List<ShaderGraph::Connection> conns;
 
-        graph->get_node_connections(type,&conns);
-        //disconnect/reconnect dependencies
-        ur->add_do_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-        ur->add_undo_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        ur->commit_action();
+	graph->get_node_connections(type,&conns);
+	//disconnect/reconnect dependencies
+	ur->add_do_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+	ur->add_undo_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
 
 
 }
 
 void ShaderGraphView::_node_removed(int p_id) {
 
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Remove Shader Graph Node");
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Remove Shader Graph Node");
 
-        ur->add_do_method(graph.ptr(),"node_remove",type,p_id);
-        ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,p_id),p_id);
-        ur->add_undo_method(graph.ptr(),"node_set_state",type,p_id,graph->node_get_state(type,p_id));
-        List<ShaderGraph::Connection> conns;
+	ur->add_do_method(graph.ptr(),"node_remove",type,p_id);
+	ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,p_id),p_id);
+	ur->add_undo_method(graph.ptr(),"node_set_state",type,p_id,graph->node_get_state(type,p_id));
+	List<ShaderGraph::Connection> conns;
 
-        graph->get_node_connections(type,&conns);
-        for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
+	graph->get_node_connections(type,&conns);
+	for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
 
-                if (E->get().dst_id==p_id || E->get().src_id==p_id) {
-                        ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
-                }
-        }
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        ur->commit_action();
+		if (E->get().dst_id==p_id || E->get().src_id==p_id) {
+			ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+		}
+	}
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
 
 }
 
 void ShaderGraphView::_begin_node_move()
 {
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Move Shader Graph Node");
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Move Shader Graph Node");
 }
 
 void ShaderGraphView::_node_moved(const Vector2& p_from, const Vector2& p_to,int p_id) {
 
 
-        ERR_FAIL_COND(!node_map.has(p_id));
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->add_do_method(this,"_move_node",p_id,p_to);
-        ur->add_undo_method(this,"_move_node",p_id,p_from);
+	ERR_FAIL_COND(!node_map.has(p_id));
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->add_do_method(this,"_move_node",p_id,p_to);
+	ur->add_undo_method(this,"_move_node",p_id,p_from);
 }
 
 void ShaderGraphView::_end_node_move()
 {
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->commit_action();
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->commit_action();
 }
 
 void ShaderGraphView::_move_node(int p_id,const Vector2& p_to) {
 
-        ERR_FAIL_COND(!node_map.has(p_id));
-        node_map[p_id]->set_offset(p_to);
-        graph->node_set_pos(type,p_id,p_to);
+	ERR_FAIL_COND(!node_map.has(p_id));
+	node_map[p_id]->set_offset(p_to);
+	graph->node_set_pos(type,p_id,p_to);
 }
 
 
 void ShaderGraphView::_create_node(int p_id) {
 
 
-        GraphNode *gn = memnew( GraphNode );
-        gn->set_show_close_button(true);
-        Color typecol[4]={
-                Color(0.9,0.4,1),
-                Color(0.8,1,0.2),
-                Color(1,0.2,0.2),
-                Color(0,1,1)
-        };
-
-
-        switch(graph->node_get_type(type,p_id)) {
-
-                case ShaderGraph::NODE_INPUT: {
-
-                        gn->set_title("Input");
-
-                        List<ShaderGraph::SlotInfo> si;
-                        ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
-
-                        int idx=0;
-                        for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
-                                ShaderGraph::SlotInfo& s=E->get();
-                                if (s.dir==ShaderGraph::SLOT_IN) {
-
-                                        Label *l= memnew( Label );
-                                        l->set_text(s.name);
-                                        l->set_align(Label::ALIGN_RIGHT);
-                                        gn->add_child(l);
-                                        gn->set_slot(idx,false,0,Color(),true,s.type,typecol[s.type]);
-                                        idx++;
-                                }
-                        }
-
-                } break; // all inputs (case Shader type dependent)
-                case ShaderGraph::NODE_SCALAR_CONST: {
-                        gn->set_title("Scalar");
-                        SpinBox *sb = memnew( SpinBox );
-                        sb->set_min(-100000);
-                        sb->set_max(100000);
-                        sb->set_step(0.001);
-                        sb->set_val(graph->scalar_const_node_get_value(type,p_id));
-                        sb->connect("value_changed",this,"_scalar_const_changed",varray(p_id));
-                        gn->add_child(sb);
-                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; //scalar constant
-                case ShaderGraph::NODE_VEC_CONST: {
-
-                        gn->set_title("Vector");
-                        Array v3p(true);
-                        for(int i=0;i<3;i++) {
-                                HBoxContainer *hbc = memnew( HBoxContainer );
-                                Label *l = memnew( Label );
-                                l->set_text(String::chr('X'+i));
-                                hbc->add_child(l);
-                                SpinBox *sb = memnew( SpinBox );
-                                sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
-                                sb->set_min(-100000);
-                                sb->set_max(100000);
-                                sb->set_step(0.001);
-                                sb->set_val(graph->vec_const_node_get_value(type,p_id)[i]);
-                                sb->connect("value_changed",this,"_vec_const_changed",varray(p_id,v3p));
-                                v3p.push_back(sb);
-                                hbc->add_child(sb);
-                                gn->add_child(hbc);
-                        }
-                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-                } break; //vec3 constant
-                case ShaderGraph::NODE_RGB_CONST: {
-
-                        gn->set_title("Color");
-                        ColorPickerButton *cpb = memnew( ColorPickerButton );
-                        cpb->set_color(graph->rgb_const_node_get_value(type,p_id));
-                        cpb->connect("color_changed",this,"_rgb_const_changed",varray(p_id));
-                        gn->add_child(cpb);
-                        Label *l = memnew( Label );
-                        l->set_text("RGB");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-                        l = memnew( Label );
-                        l->set_text("Alpha");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; //rgb constant (shows a color picker instead)
-                case ShaderGraph::NODE_XFORM_CONST: {
-                        gn->set_title("XForm");
-                        ToolButton *edit = memnew( ToolButton );
-                        edit->set_text("edit..");
-                        edit->connect("pressed",this,"_xform_const_changed",varray(p_id,edit));
-                        gn->add_child(edit);
-                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-
-                } break; // 4x4 matrix constant
-                case ShaderGraph::NODE_TIME: {
-
-                        gn->set_title("Time");
-                        Label *l = memnew( Label );
-                        l->set_text("(s)");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-                        gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; // time in seconds
-                case ShaderGraph::NODE_SCREEN_TEX: {
-
-                        gn->set_title("ScreenTex");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("UV")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("RGB")));
-                        gn->add_child(hbc);
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-                } break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
-                case ShaderGraph::NODE_SCALAR_OP: {
-
-                        gn->set_title("ScalarOp");
-                        static const char* op_name[ShaderGraph::SCALAR_MAX_OP]={
-                                "Add",
-                                "Sub",
-                                "Mul",
-                                "Div",
-                                "Mod",
-                                "Pow",
-                                "Max",
-                                "Min",
-                                "Atan2"
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::SCALAR_MAX_OP;i++) {
-
-                                ob->add_item(op_name[i],i);
-                        }
-
-                        ob->select(graph->scalar_op_node_get_op(type,p_id));
-                        ob->connect("item_selected",this,"_scalar_op_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-                } break; // scalar vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
-                case ShaderGraph::NODE_VEC_OP: {
-
-                        gn->set_title("VecOp");
-                        static const char* op_name[ShaderGraph::VEC_MAX_OP]={
-                                "Add",
-                                "Sub",
-                                "Mul",
-                                "Div",
-                                "Mod",
-                                "Pow",
-                                "Max",
-                                "Min",
-                                "Cross"
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::VEC_MAX_OP;i++) {
-
-                                ob->add_item(op_name[i],i);
-                        }
-
-                        ob->select(graph->vec_op_node_get_op(type,p_id));
-                        ob->connect("item_selected",this,"_vec_op_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-
-                } break; // vec3 vs vec3 op (mul: { } break;ad: { } break;div: { } break;crossprod: { } break;etc)
-                case ShaderGraph::NODE_VEC_SCALAR_OP: {
-
-                        gn->set_title("VecScalarOp");
-                        static const char* op_name[ShaderGraph::VEC_SCALAR_MAX_OP]={
-                                "Mul",
-                                "Div",
-                                "Pow",
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::VEC_SCALAR_MAX_OP;i++) {
-
-                                ob->add_item(op_name[i],i);
-                        }
-
-                        ob->select(graph->vec_scalar_op_node_get_op(type,p_id));
-                        ob->connect("item_selected",this,"_vec_scalar_op_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-                } break; // vec3 vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
-                case ShaderGraph::NODE_RGB_OP: {
-
-                        gn->set_title("RGB Op");
-                        static const char* op_name[ShaderGraph::RGB_MAX_OP]={
-                                "Screen",
-                                "Difference",
-                                "Darken",
-                                "Lighten",
-                                "Overlay",
-                                "Dodge",
-                                "Burn",
-                                "SoftLight",
-                                "HardLight"
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::RGB_MAX_OP;i++) {
-
-                                ob->add_item(op_name[i],i);
-                        }
-
-                        ob->select(graph->rgb_op_node_get_op(type,p_id));
-                        ob->connect("item_selected",this,"_rgb_op_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-                } break; // vec3 vs vec3 rgb op (with scalar amount): { } break; like brighten: { } break; darken: { } break; burn: { } break; dodge: { } break; multiply: { } break; etc.
-                case ShaderGraph::NODE_XFORM_MULT: {
-
-                        gn->set_title("XFMult");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
-
-
-                } break; // mat4 x mat4
-                case ShaderGraph::NODE_XFORM_VEC_MULT: {
-
-                        gn->set_title("XFVecMult");
-
-                        Button *button = memnew( Button("RotOnly"));
-                        button->set_toggle_mode(true);
-                        button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
-                        button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
-
-                        gn->add_child(button);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("xf")));
-                        hbc->add_spacer();
-                        Label *l = memnew(Label("out"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("vec")));
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-                } break;
-                case ShaderGraph::NODE_XFORM_VEC_INV_MULT: {
-
-                        gn->set_title("XFVecInvMult");
-
-
-                        Button *button = memnew( Button("RotOnly"));
-                        button->set_toggle_mode(true);
-                        button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
-                        button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
-
-                        gn->add_child(button);
-
-                        gn->add_child( memnew(Label("vec")));
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("xf")));
-                        hbc->add_spacer();
-                        Label *l = memnew(Label("out"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-
-                } break; // mat4 x vec3 inverse mult (with no-translation option)
-                case ShaderGraph::NODE_SCALAR_FUNC: {
-
-                        gn->set_title("ScalarFunc");
-                        static const char* func_name[ShaderGraph::SCALAR_MAX_FUNC]={
-                                "Sin",
-                                "Cos",
-                                "Tan",
-                                "ASin",
-                                "ACos",
-                                "ATan",
-                                "SinH",
-                                "CosH",
-                                "TanH",
-                                "Log",
-                                "Exp",
-                                "Sqrt",
-                                "Abs",
-                                "Sign",
-                                "Floor",
-                                "Round",
-                                "Ceil",
-                                "Frac",
-                                "Satr",
-                                "Neg"
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::SCALAR_MAX_FUNC;i++) {
-
-                                ob->add_item(func_name[i],i);
-                        }
-
-                        ob->select(graph->scalar_func_node_get_function(type,p_id));
-                        ob->connect("item_selected",this,"_scalar_func_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_child( memnew(Label("in")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-                } break; // scalar function (sin: { } break; cos: { } break; etc)
-                case ShaderGraph::NODE_VEC_FUNC: {
-
-
-
-                        gn->set_title("VecFunc");
-                        static const char* func_name[ShaderGraph::VEC_MAX_FUNC]={
-                                "Normalize",
-                                "Saturate",
-                                "Negate",
-                                "Reciprocal",
-                                "RGB to HSV",
-                                "HSV to RGB",
-                        };
-
-                        OptionButton *ob = memnew( OptionButton );
-                        for(int i=0;i<ShaderGraph::VEC_MAX_FUNC;i++) {
-
-                                ob->add_item(func_name[i],i);
-                        }
-
-                        ob->select(graph->vec_func_node_get_function(type,p_id));
-                        ob->connect("item_selected",this,"_vec_func_changed",varray(p_id));
-                        gn->add_child(ob);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("in")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("out")));
-                        gn->add_child(hbc);
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-                } break; // vector function (normalize: { } break; negate: { } break; reciprocal: { } break; rgb2hsv: { } break; hsv2rgb: { } break; etc: { } break; etc)
-                case ShaderGraph::NODE_VEC_LEN: {
-                        gn->set_title("VecLength");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_child( memnew(Label("in")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("len")));
-                        gn->add_child(hbc);
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; // vec3 length
-                case ShaderGraph::NODE_DOT_PROD: {
-
-                        gn->set_title("DotProduct");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("dp")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-                } break; // vec3 . vec3 (dot product -> scalar output)
-                case ShaderGraph::NODE_VEC_TO_SCALAR: {
-
-                        gn->set_title("Vec2Scalar");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("vec")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("x"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-                        l=memnew(Label("y"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l );
-                        l=memnew(Label("z"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l);
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-
-
-                } break; // 1 vec3 input: { } break; 3 scalar outputs
-                case ShaderGraph::NODE_SCALAR_TO_VEC: {
-
-                        gn->set_title("Scalar2Vec");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_child( memnew(Label("x")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("vec")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("y")));
-                        gn->add_child( memnew(Label("z")));
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-                } break; // 3 scalar input: { } break; 1 vec3 output
-                case ShaderGraph::NODE_VEC_TO_XFORM: {
-
-                        gn->set_title("Vec2XForm");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("x")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("xf")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("y")));
-                        gn->add_child( memnew(Label("z")));
-                        gn->add_child( memnew(Label("ofs")));
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-                        gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-
-                } break; // 3 vec input: { } break; 1 xform output
-                case ShaderGraph::NODE_XFORM_TO_VEC: {
-
-                        gn->set_title("XForm2Vec");
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("xf")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("x"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-                        l=memnew(Label("y"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l );
-                        l=memnew(Label("z"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l);
-                        l=memnew(Label("ofs"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l);
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-                } break; // 3 vec input: { } break; 1 xform output
-                case ShaderGraph::NODE_SCALAR_INTERP: {
-
-                        gn->set_title("ScalarInterp");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("interp")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-                        gn->add_child( memnew(Label("c")));
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
-
-
-                } break; // scalar interpolation (with optional curve)
-                case ShaderGraph::NODE_VEC_INTERP: {
-
-                        gn->set_title("VecInterp");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_child( memnew(Label("a")));
-                        hbc->add_spacer();
-                        hbc->add_child( memnew(Label("interp")));
-                        gn->add_child(hbc);
-                        gn->add_child( memnew(Label("b")));
-                        gn->add_child( memnew(Label("c")));
+	GraphNode *gn = memnew( GraphNode );
+	gn->set_show_close_button(true);
+	Color typecol[4]={
+		Color(0.9,0.4,1),
+		Color(0.8,1,0.2),
+		Color(1,0.2,0.2),
+		Color(0,1,1)
+	};
+
+
+	switch(graph->node_get_type(type,p_id)) {
+
+	case ShaderGraph::NODE_INPUT: {
+
+		gn->set_title("Input");
+
+		List<ShaderGraph::SlotInfo> si;
+		ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
+
+		int idx=0;
+		for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
+			ShaderGraph::SlotInfo& s=E->get();
+			if (s.dir==ShaderGraph::SLOT_IN) {
+
+				Label *l= memnew( Label );
+				l->set_text(s.name);
+				l->set_align(Label::ALIGN_RIGHT);
+				gn->add_child(l);
+				gn->set_slot(idx,false,0,Color(),true,s.type,typecol[s.type]);
+				idx++;
+			}
+		}
+
+	} break; // all inputs (case Shader type dependent)
+	case ShaderGraph::NODE_SCALAR_CONST: {
+		gn->set_title("Scalar");
+		SpinBox *sb = memnew( SpinBox );
+		sb->set_min(-100000);
+		sb->set_max(100000);
+		sb->set_step(0.001);
+		sb->set_val(graph->scalar_const_node_get_value(type,p_id));
+		sb->connect("value_changed",this,"_scalar_const_changed",varray(p_id));
+		gn->add_child(sb);
+		gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; //scalar constant
+	case ShaderGraph::NODE_VEC_CONST: {
+
+		gn->set_title("Vector");
+		Array v3p(true);
+		for(int i=0;i<3;i++) {
+			HBoxContainer *hbc = memnew( HBoxContainer );
+			Label *l = memnew( Label );
+			l->set_text(String::chr('X'+i));
+			hbc->add_child(l);
+			SpinBox *sb = memnew( SpinBox );
+			sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
+			sb->set_min(-100000);
+			sb->set_max(100000);
+			sb->set_step(0.001);
+			sb->set_val(graph->vec_const_node_get_value(type,p_id)[i]);
+			sb->connect("value_changed",this,"_vec_const_changed",varray(p_id,v3p));
+			v3p.push_back(sb);
+			hbc->add_child(sb);
+			gn->add_child(hbc);
+		}
+		gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+	} break; //vec3 constant
+	case ShaderGraph::NODE_RGB_CONST: {
+
+		gn->set_title("Color");
+		ColorPickerButton *cpb = memnew( ColorPickerButton );
+		cpb->set_color(graph->rgb_const_node_get_value(type,p_id));
+		cpb->connect("color_changed",this,"_rgb_const_changed",varray(p_id));
+		gn->add_child(cpb);
+		Label *l = memnew( Label );
+		l->set_text("RGB");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+		l = memnew( Label );
+		l->set_text("Alpha");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; //rgb constant (shows a color picker instead)
+	case ShaderGraph::NODE_XFORM_CONST: {
+		gn->set_title("XForm");
+		ToolButton *edit = memnew( ToolButton );
+		edit->set_text("edit..");
+		edit->connect("pressed",this,"_xform_const_changed",varray(p_id,edit));
+		gn->add_child(edit);
+		gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+
+	} break; // 4x4 matrix constant
+	case ShaderGraph::NODE_TIME: {
+
+		gn->set_title("Time");
+		Label *l = memnew( Label );
+		l->set_text("(s)");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+		gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; // time in seconds
+	case ShaderGraph::NODE_SCREEN_TEX: {
+
+		gn->set_title("ScreenTex");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("UV")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("RGB")));
+		gn->add_child(hbc);
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+	} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
+	case ShaderGraph::NODE_SCALAR_OP: {
+
+		gn->set_title("ScalarOp");
+		static const char* op_name[ShaderGraph::SCALAR_MAX_OP]={
+			"Add",
+			"Sub",
+			"Mul",
+			"Div",
+			"Mod",
+			"Pow",
+			"Max",
+			"Min",
+			"Atan2"
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::SCALAR_MAX_OP;i++) {
+
+			ob->add_item(op_name[i],i);
+		}
+
+		ob->select(graph->scalar_op_node_get_op(type,p_id));
+		ob->connect("item_selected",this,"_scalar_op_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+	} break; // scalar vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
+	case ShaderGraph::NODE_VEC_OP: {
+
+		gn->set_title("VecOp");
+		static const char* op_name[ShaderGraph::VEC_MAX_OP]={
+			"Add",
+			"Sub",
+			"Mul",
+			"Div",
+			"Mod",
+			"Pow",
+			"Max",
+			"Min",
+			"Cross"
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::VEC_MAX_OP;i++) {
+
+			ob->add_item(op_name[i],i);
+		}
+
+		ob->select(graph->vec_op_node_get_op(type,p_id));
+		ob->connect("item_selected",this,"_vec_op_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+
+	} break; // vec3 vs vec3 op (mul: { } break;ad: { } break;div: { } break;crossprod: { } break;etc)
+	case ShaderGraph::NODE_VEC_SCALAR_OP: {
+
+		gn->set_title("VecScalarOp");
+		static const char* op_name[ShaderGraph::VEC_SCALAR_MAX_OP]={
+			"Mul",
+			"Div",
+			"Pow",
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::VEC_SCALAR_MAX_OP;i++) {
+
+			ob->add_item(op_name[i],i);
+		}
+
+		ob->select(graph->vec_scalar_op_node_get_op(type,p_id));
+		ob->connect("item_selected",this,"_vec_scalar_op_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+	} break; // vec3 vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
+	case ShaderGraph::NODE_RGB_OP: {
+
+		gn->set_title("RGB Op");
+		static const char* op_name[ShaderGraph::RGB_MAX_OP]={
+			"Screen",
+			"Difference",
+			"Darken",
+			"Lighten",
+			"Overlay",
+			"Dodge",
+			"Burn",
+			"SoftLight",
+			"HardLight"
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::RGB_MAX_OP;i++) {
+
+			ob->add_item(op_name[i],i);
+		}
+
+		ob->select(graph->rgb_op_node_get_op(type,p_id));
+		ob->connect("item_selected",this,"_rgb_op_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+	} break; // vec3 vs vec3 rgb op (with scalar amount): { } break; like brighten: { } break; darken: { } break; burn: { } break; dodge: { } break; multiply: { } break; etc.
+	case ShaderGraph::NODE_XFORM_MULT: {
+
+		gn->set_title("XFMult");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
+
+
+	} break; // mat4 x mat4
+	case ShaderGraph::NODE_XFORM_VEC_MULT: {
+
+		gn->set_title("XFVecMult");
+
+		Button *button = memnew( Button("RotOnly"));
+		button->set_toggle_mode(true);
+		button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
+		button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
+
+		gn->add_child(button);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("xf")));
+		hbc->add_spacer();
+		Label *l = memnew(Label("out"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("vec")));
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+	} break;
+	case ShaderGraph::NODE_XFORM_VEC_INV_MULT: {
+
+		gn->set_title("XFVecInvMult");
+
+
+		Button *button = memnew( Button("RotOnly"));
+		button->set_toggle_mode(true);
+		button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
+		button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
+
+		gn->add_child(button);
+
+		gn->add_child( memnew(Label("vec")));
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("xf")));
+		hbc->add_spacer();
+		Label *l = memnew(Label("out"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+
+	} break; // mat4 x vec3 inverse mult (with no-translation option)
+	case ShaderGraph::NODE_SCALAR_FUNC: {
+
+		gn->set_title("ScalarFunc");
+		static const char* func_name[ShaderGraph::SCALAR_MAX_FUNC]={
+			"Sin",
+			"Cos",
+			"Tan",
+			"ASin",
+			"ACos",
+			"ATan",
+			"SinH",
+			"CosH",
+			"TanH",
+			"Log",
+			"Exp",
+			"Sqrt",
+			"Abs",
+			"Sign",
+			"Floor",
+			"Round",
+			"Ceil",
+			"Frac",
+			"Satr",
+			"Neg"
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::SCALAR_MAX_FUNC;i++) {
+
+			ob->add_item(func_name[i],i);
+		}
+
+		ob->select(graph->scalar_func_node_get_function(type,p_id));
+		ob->connect("item_selected",this,"_scalar_func_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_child( memnew(Label("in")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+	} break; // scalar function (sin: { } break; cos: { } break; etc)
+	case ShaderGraph::NODE_VEC_FUNC: {
+
+
+
+		gn->set_title("VecFunc");
+		static const char* func_name[ShaderGraph::VEC_MAX_FUNC]={
+			"Normalize",
+			"Saturate",
+			"Negate",
+			"Reciprocal",
+			"RGB to HSV",
+			"HSV to RGB",
+		};
+
+		OptionButton *ob = memnew( OptionButton );
+		for(int i=0;i<ShaderGraph::VEC_MAX_FUNC;i++) {
+
+			ob->add_item(func_name[i],i);
+		}
+
+		ob->select(graph->vec_func_node_get_function(type,p_id));
+		ob->connect("item_selected",this,"_vec_func_changed",varray(p_id));
+		gn->add_child(ob);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("in")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("out")));
+		gn->add_child(hbc);
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+	} break; // vector function (normalize: { } break; negate: { } break; reciprocal: { } break; rgb2hsv: { } break; hsv2rgb: { } break; etc: { } break; etc)
+	case ShaderGraph::NODE_VEC_LEN: {
+		gn->set_title("VecLength");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_child( memnew(Label("in")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("len")));
+		gn->add_child(hbc);
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; // vec3 length
+	case ShaderGraph::NODE_DOT_PROD: {
+
+		gn->set_title("DotProduct");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("dp")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+	} break; // vec3 . vec3 (dot product -> scalar output)
+	case ShaderGraph::NODE_VEC_TO_SCALAR: {
+
+		gn->set_title("Vec2Scalar");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("vec")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("x"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+		l=memnew(Label("y"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l );
+		l=memnew(Label("z"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l);
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+		gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+
+
+	} break; // 1 vec3 input: { } break; 3 scalar outputs
+	case ShaderGraph::NODE_SCALAR_TO_VEC: {
+
+		gn->set_title("Scalar2Vec");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_child( memnew(Label("x")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("vec")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("y")));
+		gn->add_child( memnew(Label("z")));
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+	} break; // 3 scalar input: { } break; 1 vec3 output
+	case ShaderGraph::NODE_VEC_TO_XFORM: {
+
+		gn->set_title("Vec2XForm");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("x")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("xf")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("y")));
+		gn->add_child( memnew(Label("z")));
+		gn->add_child( memnew(Label("ofs")));
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+		gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+
+	} break; // 3 vec input: { } break; 1 xform output
+	case ShaderGraph::NODE_XFORM_TO_VEC: {
+
+		gn->set_title("XForm2Vec");
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("xf")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("x"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+		l=memnew(Label("y"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l );
+		l=memnew(Label("z"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l);
+		l=memnew(Label("ofs"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l);
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+	} break; // 3 vec input: { } break; 1 xform output
+	case ShaderGraph::NODE_SCALAR_INTERP: {
+
+		gn->set_title("ScalarInterp");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("interp")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+		gn->add_child( memnew(Label("c")));
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+
+
+	} break; // scalar interpolation (with optional curve)
+	case ShaderGraph::NODE_VEC_INTERP: {
+
+		gn->set_title("VecInterp");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_child( memnew(Label("a")));
+		hbc->add_spacer();
+		hbc->add_child( memnew(Label("interp")));
+		gn->add_child(hbc);
+		gn->add_child( memnew(Label("b")));
+		gn->add_child( memnew(Label("c")));
 
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
 
-                } break; // vec3 interpolation  (with optional curve)
-                case ShaderGraph::NODE_COLOR_RAMP: {
-
-                        gn->set_title("ColorRamp");
-                        GraphColorRampEdit * ramp  = memnew( GraphColorRampEdit );
-
-                        DVector<real_t> offsets = graph->color_ramp_node_get_offsets(type,p_id);
-                        DVector<Color> colors = graph->color_ramp_node_get_colors(type,p_id);
-
-                        int oc = offsets.size();
-
-                        if (oc) {
-                                DVector<real_t>::Read rofs = offsets.read();
-                                DVector<Color>::Read rcol = colors.read();
-
-                                Vector<float> ofsv;
-                                Vector<Color> colorv;
-                                for(int i=0;i<oc;i++) {
-                                        ofsv.push_back(rofs[i]);
-                                        colorv.push_back(rcol[i]);
-                                }
-
-                                ramp->set_ramp(ofsv,colorv);
-
-                        }
-
-                        ramp->connect("ramp_changed",this,"_color_ramp_changed",varray(p_id,ramp));
-                        ramp->set_custom_minimum_size(Size2(128,1));
-                        gn->add_child(ramp);
-
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("c")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("rgb"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-                        l=memnew(Label("alpha"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child( l);
-
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(2,false,ShaderGraph::SLOT_MAX,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-                } break; // scalar interpolation (with optional curve)
-                case ShaderGraph::NODE_CURVE_MAP: {
-
-                        gn->set_title("CurveMap");
-                        GraphCurveMapEdit * map  = memnew( GraphCurveMapEdit );
-
-                        DVector<Vector2> points = graph->curve_map_node_get_points(type,p_id);
-
-                        int oc = points.size();
-
-                        if (oc) {
-                                DVector<Vector2>::Read rofs = points.read();
-
-
-                                Vector<Vector2> ofsv;
-                                for(int i=0;i<oc;i++) {
-                                        ofsv.push_back(rofs[i]);
-                                }
-
-                                map->set_points(ofsv);
-
-                        }
-                        map->connect("curve_changed",this,"_curve_changed",varray(p_id,map));
-
-                        //map->connect("map_changed",this,"_curve_map_changed",varray(p_id,map));
-                        map->set_custom_minimum_size(Size2(128,64));
-                        gn->add_child(map);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("c")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("cmap"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child( l);
-                        gn->add_child(hbc);
-
-
-                        gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-                } break; // scalar interpolation (with optional curve)
-
-                case ShaderGraph::NODE_SCALAR_INPUT: {
-
-                        gn->set_title("ScalarUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-                        SpinBox *sb = memnew( SpinBox );
-                        sb->set_min(-100000);
-                        sb->set_max(100000);
-                        sb->set_step(0.001);
-                        sb->set_val(graph->scalar_input_node_get_value(type,p_id));
-                        sb->connect("value_changed",this,"_scalar_input_changed",varray(p_id));
-                        gn->add_child(sb);
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; // scalar uniform (assignable in material)
-                case ShaderGraph::NODE_VEC_INPUT: {
-
-                        gn->set_title("VectorUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-                        Array v3p(true);
-                        for(int i=0;i<3;i++) {
-                                HBoxContainer *hbc = memnew( HBoxContainer );
-                                Label *l = memnew( Label );
-                                l->set_text(String::chr('X'+i));
-                                hbc->add_child(l);
-                                SpinBox *sb = memnew( SpinBox );
-                                sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
-                                sb->set_min(-100000);
-                                sb->set_max(100000);
-                                sb->set_step(0.001);
-                                sb->set_val(graph->vec_input_node_get_value(type,p_id)[i]);
-                                sb->connect("value_changed",this,"_vec_input_changed",varray(p_id,v3p));
-                                v3p.push_back(sb);
-                                hbc->add_child(sb);
-                                gn->add_child(hbc);
-                        }
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-
-                } break; // vec3 uniform (assignable in material)
-                case ShaderGraph::NODE_RGB_INPUT: {
-
-                        gn->set_title("ColorUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-                        ColorPickerButton *cpb = memnew( ColorPickerButton );
-                        cpb->set_color(graph->rgb_input_node_get_value(type,p_id));
-                        cpb->connect("color_changed",this,"_rgb_input_changed",varray(p_id));
-                        gn->add_child(cpb);
-                        Label *l = memnew( Label );
-                        l->set_text("RGB");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-                        l = memnew( Label );
-                        l->set_text("Alpha");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-
-                        gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-                } break; // color uniform (assignable in material)
-                case ShaderGraph::NODE_XFORM_INPUT: {
-                        gn->set_title("XFUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-                        ToolButton *edit = memnew( ToolButton );
-                        edit->set_text("edit..");
-                        edit->connect("pressed",this,"_xform_input_changed",varray(p_id,edit));
-                        gn->add_child(edit);
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
-
-                } break; // mat4 uniform (assignable in material)
-                case ShaderGraph::NODE_TEXTURE_INPUT: {
-
-                        gn->set_title("TexUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-                        TextureFrame *tex = memnew( TextureFrame );
-                        tex->set_expand(true);
-                        tex->set_custom_minimum_size(Size2(80,80));
-                        gn->add_child(tex);
-                        tex->set_texture(graph->texture_input_node_get_value(type,p_id));
-                        ToolButton *edit = memnew( ToolButton );
-                        edit->set_text("edit..");
-                        edit->connect("pressed",this,"_tex_edited",varray(p_id,edit));
-                        gn->add_child(edit);
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("UV")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("RGB"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child(l);
-                        gn->add_child(hbc);
-                        l = memnew( Label );
-                        l->set_text("Alpha");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-
-                        gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(4,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; // texture input (assignable in material)
-                case ShaderGraph::NODE_CUBEMAP_INPUT: {
-
-                        gn->set_title("TexUniform");
-                        LineEdit *le = memnew( LineEdit );
-                        gn->add_child(le);
-                        le->set_text(graph->input_node_get_name(type,p_id));
-                        le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
-
-                        ToolButton *edit = memnew( ToolButton );
-                        edit->set_text("edit..");
-                        edit->connect("pressed",this,"_cube_edited",varray(p_id,edit));
-                        gn->add_child(edit);
-
-
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("UV")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("RGB"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child(l);
-                        gn->add_child(hbc);
-                        l = memnew( Label );
-                        l->set_text("Alpha");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-
-                        gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-                } break; // cubemap input (assignable in material)
-                case ShaderGraph::NODE_DEFAULT_TEXTURE: {
-
-                        gn->set_title("CanvasItemTex");
-                        HBoxContainer *hbc = memnew( HBoxContainer );
-                        hbc->add_constant_override("separation",0);
-                        hbc->add_child( memnew(Label("UV")));
-                        hbc->add_spacer();
-                        Label *l=memnew(Label("RGB"));
-                        l->set_align(Label::ALIGN_RIGHT);
-                        hbc->add_child(l);
-                        gn->add_child(hbc);
-                        l = memnew( Label );
-                        l->set_text("Alpha");
-                        l->set_align(Label::ALIGN_RIGHT);
-                        gn->add_child(l);
-
-                        gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
-                        gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
-
-
-                } break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
-
-                case ShaderGraph::NODE_OUTPUT: {
-                        gn->set_title("Output");
-                        gn->set_show_close_button(false);
-
-                        List<ShaderGraph::SlotInfo> si;
-                        ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
-
-                        int idx=0;
-                        for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
-                                ShaderGraph::SlotInfo& s=E->get();
-                                if (s.dir==ShaderGraph::SLOT_OUT) {
-
-                                        Label *l= memnew( Label );
-                                        l->set_text(s.name);
-                                        l->set_align(Label::ALIGN_LEFT);
-                                        gn->add_child(l);
-                                        gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
-                                        idx++;
-                                }
-                        }
-
-                } break; // output (case Shader type dependent)
-                case ShaderGraph::NODE_COMMENT: {
-                        gn->set_title("Comment");
-                        TextEdit *te = memnew(TextEdit);
-                        te->set_custom_minimum_size(Size2(100,100));
-                        gn->add_child(te);
-                        te->set_text(graph->comment_node_get_text(type,p_id));
-                        te->connect("text_changed",this,"_comment_edited",varray(p_id,te));
-
-                } break; // comment
-
-
-
-        }
-
-        gn->connect("dragged",this,"_node_moved",varray(p_id));
-        gn->connect("close_request",this,"_node_removed",varray(p_id),CONNECT_DEFERRED);
-        graph_edit->add_child(gn);
-        node_map[p_id]=gn;
-        gn->set_offset(graph->node_get_pos(type,p_id));
+	} break; // vec3 interpolation  (with optional curve)
+	case ShaderGraph::NODE_COLOR_RAMP: {
+
+		gn->set_title("ColorRamp");
+		GraphColorRampEdit * ramp  = memnew( GraphColorRampEdit );
+
+		DVector<real_t> offsets = graph->color_ramp_node_get_offsets(type,p_id);
+		DVector<Color> colors = graph->color_ramp_node_get_colors(type,p_id);
+
+		int oc = offsets.size();
+
+		if (oc) {
+			DVector<real_t>::Read rofs = offsets.read();
+			DVector<Color>::Read rcol = colors.read();
+
+			Vector<float> ofsv;
+			Vector<Color> colorv;
+			for(int i=0;i<oc;i++) {
+				ofsv.push_back(rofs[i]);
+				colorv.push_back(rcol[i]);
+			}
+
+			ramp->set_ramp(ofsv,colorv);
+
+		}
+
+		ramp->connect("ramp_changed",this,"_color_ramp_changed",varray(p_id,ramp));
+		ramp->set_custom_minimum_size(Size2(128,1));
+		gn->add_child(ramp);
+
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("c")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("rgb"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+		l=memnew(Label("alpha"));
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child( l);
+
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(2,false,ShaderGraph::SLOT_MAX,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+	} break; // scalar interpolation (with optional curve)
+	case ShaderGraph::NODE_CURVE_MAP: {
+
+		gn->set_title("CurveMap");
+		GraphCurveMapEdit * map  = memnew( GraphCurveMapEdit );
+
+		DVector<Vector2> points = graph->curve_map_node_get_points(type,p_id);
+
+		int oc = points.size();
+
+		if (oc) {
+			DVector<Vector2>::Read rofs = points.read();
+
+
+			Vector<Vector2> ofsv;
+			for(int i=0;i<oc;i++) {
+				ofsv.push_back(rofs[i]);
+			}
+
+			map->set_points(ofsv);
+
+		}
+		map->connect("curve_changed",this,"_curve_changed",varray(p_id,map));
+
+		//map->connect("map_changed",this,"_curve_map_changed",varray(p_id,map));
+		map->set_custom_minimum_size(Size2(128,64));
+		gn->add_child(map);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("c")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("cmap"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child( l);
+		gn->add_child(hbc);
+
+
+		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+	} break; // scalar interpolation (with optional curve)
+
+	case ShaderGraph::NODE_SCALAR_INPUT: {
+
+		gn->set_title("ScalarUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+		SpinBox *sb = memnew( SpinBox );
+		sb->set_min(-100000);
+		sb->set_max(100000);
+		sb->set_step(0.001);
+		sb->set_val(graph->scalar_input_node_get_value(type,p_id));
+		sb->connect("value_changed",this,"_scalar_input_changed",varray(p_id));
+		gn->add_child(sb);
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; // scalar uniform (assignable in material)
+	case ShaderGraph::NODE_VEC_INPUT: {
+
+		gn->set_title("VectorUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+		Array v3p(true);
+		for(int i=0;i<3;i++) {
+			HBoxContainer *hbc = memnew( HBoxContainer );
+			Label *l = memnew( Label );
+			l->set_text(String::chr('X'+i));
+			hbc->add_child(l);
+			SpinBox *sb = memnew( SpinBox );
+			sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
+			sb->set_min(-100000);
+			sb->set_max(100000);
+			sb->set_step(0.001);
+			sb->set_val(graph->vec_input_node_get_value(type,p_id)[i]);
+			sb->connect("value_changed",this,"_vec_input_changed",varray(p_id,v3p));
+			v3p.push_back(sb);
+			hbc->add_child(sb);
+			gn->add_child(hbc);
+		}
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+
+	} break; // vec3 uniform (assignable in material)
+	case ShaderGraph::NODE_RGB_INPUT: {
+
+		gn->set_title("ColorUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+		ColorPickerButton *cpb = memnew( ColorPickerButton );
+		cpb->set_color(graph->rgb_input_node_get_value(type,p_id));
+		cpb->connect("color_changed",this,"_rgb_input_changed",varray(p_id));
+		gn->add_child(cpb);
+		Label *l = memnew( Label );
+		l->set_text("RGB");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+		l = memnew( Label );
+		l->set_text("Alpha");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+
+		gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+	} break; // color uniform (assignable in material)
+	case ShaderGraph::NODE_XFORM_INPUT: {
+		gn->set_title("XFUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+		ToolButton *edit = memnew( ToolButton );
+		edit->set_text("edit..");
+		edit->connect("pressed",this,"_xform_input_changed",varray(p_id,edit));
+		gn->add_child(edit);
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
+
+	} break; // mat4 uniform (assignable in material)
+	case ShaderGraph::NODE_TEXTURE_INPUT: {
+
+		gn->set_title("TexUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+		TextureFrame *tex = memnew( TextureFrame );
+		tex->set_expand(true);
+		tex->set_custom_minimum_size(Size2(80,80));
+		gn->add_child(tex);
+		tex->set_texture(graph->texture_input_node_get_value(type,p_id));
+		ToolButton *edit = memnew( ToolButton );
+		edit->set_text("edit..");
+		edit->connect("pressed",this,"_tex_edited",varray(p_id,edit));
+		gn->add_child(edit);
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("UV")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("RGB"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child(l);
+		gn->add_child(hbc);
+		l = memnew( Label );
+		l->set_text("Alpha");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+
+		gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(4,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; // texture input (assignable in material)
+	case ShaderGraph::NODE_CUBEMAP_INPUT: {
+
+		gn->set_title("TexUniform");
+		LineEdit *le = memnew( LineEdit );
+		gn->add_child(le);
+		le->set_text(graph->input_node_get_name(type,p_id));
+		le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
+
+		ToolButton *edit = memnew( ToolButton );
+		edit->set_text("edit..");
+		edit->connect("pressed",this,"_cube_edited",varray(p_id,edit));
+		gn->add_child(edit);
+
+
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("UV")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("RGB"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child(l);
+		gn->add_child(hbc);
+		l = memnew( Label );
+		l->set_text("Alpha");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+
+		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+	} break; // cubemap input (assignable in material)
+	case ShaderGraph::NODE_DEFAULT_TEXTURE: {
+
+		gn->set_title("CanvasItemTex");
+		HBoxContainer *hbc = memnew( HBoxContainer );
+		hbc->add_constant_override("separation",0);
+		hbc->add_child( memnew(Label("UV")));
+		hbc->add_spacer();
+		Label *l=memnew(Label("RGB"));
+		l->set_align(Label::ALIGN_RIGHT);
+		hbc->add_child(l);
+		gn->add_child(hbc);
+		l = memnew( Label );
+		l->set_text("Alpha");
+		l->set_align(Label::ALIGN_RIGHT);
+		gn->add_child(l);
+
+		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
+		gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
+
+
+	} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
+
+	case ShaderGraph::NODE_OUTPUT: {
+		gn->set_title("Output");
+		gn->set_show_close_button(false);
+
+		List<ShaderGraph::SlotInfo> si;
+		ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
+
+		int idx=0;
+		for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
+			ShaderGraph::SlotInfo& s=E->get();
+			if (s.dir==ShaderGraph::SLOT_OUT) {
+
+				Label *l= memnew( Label );
+				l->set_text(s.name);
+				l->set_align(Label::ALIGN_LEFT);
+				gn->add_child(l);
+				gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
+				idx++;
+			}
+		}
+
+	} break; // output (case Shader type dependent)
+	case ShaderGraph::NODE_COMMENT: {
+		gn->set_title("Comment");
+		TextEdit *te = memnew(TextEdit);
+		te->set_custom_minimum_size(Size2(100,100));
+		gn->add_child(te);
+		te->set_text(graph->comment_node_get_text(type,p_id));
+		te->connect("text_changed",this,"_comment_edited",varray(p_id,te));
+
+	} break; // comment
+
+
+
+	}
+
+	gn->connect("dragged",this,"_node_moved",varray(p_id));
+	gn->connect("close_request",this,"_node_removed",varray(p_id),CONNECT_DEFERRED);
+	graph_edit->add_child(gn);
+	node_map[p_id]=gn;
+	gn->set_offset(graph->node_get_pos(type,p_id));
 
 
 }
@@ -2056,36 +2056,36 @@ void ShaderGraphView::_create_node(int p_id) {
 void ShaderGraphView::_update_graph() {
 
 
-        if (block_update)
-                return;
+	if (block_update)
+		return;
 
-        for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+	for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
 
-                memdelete(E->get());
-        }
+		memdelete(E->get());
+	}
 
-        node_map.clear();
+	node_map.clear();
 
-        if (!graph.is_valid())
-                return;
+	if (!graph.is_valid())
+		return;
 
 
-        List<int> nl;
-        graph->get_node_list(type,&nl);
+	List<int> nl;
+	graph->get_node_list(type,&nl);
 
-        for(List<int>::Element *E=nl.front();E;E=E->next()) {
+	for(List<int>::Element *E=nl.front();E;E=E->next()) {
 
-                _create_node(E->get());
-        }
-        graph_edit->clear_connections();
+		_create_node(E->get());
+	}
+	graph_edit->clear_connections();
 
-        List<ShaderGraph::Connection> connections;
-        graph->get_node_connections(type,&connections);
-        for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
+	List<ShaderGraph::Connection> connections;
+	graph->get_node_connections(type,&connections);
+	for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
 
-                ERR_CONTINUE(!node_map.has(E->get().src_id) || !node_map.has(E->get().dst_id));
-                graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
-        }
+		ERR_CONTINUE(!node_map.has(E->get().src_id) || !node_map.has(E->get().dst_id));
+		graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
+	}
 
 
 
@@ -2093,314 +2093,314 @@ void ShaderGraphView::_update_graph() {
 
 void ShaderGraphView::_sg_updated() {
 
-        if (!graph.is_valid())
-                return;
-        switch(graph->get_graph_error(type)) {
-                case ShaderGraph::GRAPH_OK: status->set_text(""); break;
-                case ShaderGraph::GRAPH_ERROR_CYCLIC: status->set_text("Error: Cyclic Connection Link"); break;
-                case ShaderGraph::GRAPH_ERROR_MISSING_CONNECTIONS: status->set_text("Error: Missing Input Connections"); break;
-        }
+	if (!graph.is_valid())
+		return;
+	switch(graph->get_graph_error(type)) {
+	case ShaderGraph::GRAPH_OK: status->set_text(""); break;
+	case ShaderGraph::GRAPH_ERROR_CYCLIC: status->set_text("Error: Cyclic Connection Link"); break;
+	case ShaderGraph::GRAPH_ERROR_MISSING_CONNECTIONS: status->set_text("Error: Missing Input Connections"); break;
+	}
 }
 
 void ShaderGraphView::set_graph(Ref<ShaderGraph> p_graph){
 
 
-        if (graph.is_valid()) {
-                graph->disconnect("updated",this,"_sg_updated");
-        }
-        graph=p_graph;
-        if (graph.is_valid()) {
-                graph->connect("updated",this,"_sg_updated");
-        }
-        _update_graph();
-        _sg_updated();
+	if (graph.is_valid()) {
+		graph->disconnect("updated",this,"_sg_updated");
+	}
+	graph=p_graph;
+	if (graph.is_valid()) {
+		graph->connect("updated",this,"_sg_updated");
+	}
+	_update_graph();
+	_sg_updated();
 
 }
 
 void ShaderGraphView::_notification(int p_what) {
 
-        if (p_what==NOTIFICATION_ENTER_TREE) {
+	if (p_what==NOTIFICATION_ENTER_TREE) {
 
-                ped_popup->connect("variant_changed",this,"_variant_edited");
-        }
- }
+		ped_popup->connect("variant_changed",this,"_variant_edited");
+	}
+}
 
 void ShaderGraphView::add_node(int p_type, const Vector2 &location) {
 
-        List<int> existing;
-        graph->get_node_list(type,&existing);
-        existing.sort();
-        int newid=1;
-        for(List<int>::Element *E=existing.front();E;E=E->next()) {
-                if (!E->next() || (E->get()+1!=E->next()->get())){
-                        newid=E->get()+1;
-                        break;
-                }
-        }
-
-        Vector2 init_ofs = location;
-        while(true) {
-                bool valid=true;
-                for(List<int>::Element *E=existing.front();E;E=E->next()) {
-                        Vector2 pos = graph->node_get_pos(type,E->get());
-                        if (init_ofs==pos) {
-                                init_ofs+=Vector2(20,20);
-                                valid=false;
-                                break;
-
-                        }
-                }
-
-                if (valid)
-                        break;
-        }
-        UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
-        ur->create_action("Add Shader Graph Node");
-        ur->add_do_method(graph.ptr(),"node_add",type,p_type,newid);
-        ur->add_do_method(graph.ptr(),"node_set_pos",type,newid,init_ofs);
-        ur->add_undo_method(graph.ptr(),"node_remove",type,newid);
-        ur->add_do_method(this,"_update_graph");
-        ur->add_undo_method(this,"_update_graph");
-        ur->commit_action();
+	List<int> existing;
+	graph->get_node_list(type,&existing);
+	existing.sort();
+	int newid=1;
+	for(List<int>::Element *E=existing.front();E;E=E->next()) {
+		if (!E->next() || (E->get()+1!=E->next()->get())){
+			newid=E->get()+1;
+			break;
+		}
+	}
+
+	Vector2 init_ofs = location;
+	while(true) {
+		bool valid=true;
+		for(List<int>::Element *E=existing.front();E;E=E->next()) {
+			Vector2 pos = graph->node_get_pos(type,E->get());
+			if (init_ofs==pos) {
+				init_ofs+=Vector2(20,20);
+				valid=false;
+				break;
+
+			}
+		}
+
+		if (valid)
+			break;
+	}
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Add Shader Graph Node");
+	ur->add_do_method(graph.ptr(),"node_add",type,p_type,newid);
+	ur->add_do_method(graph.ptr(),"node_set_pos",type,newid,init_ofs);
+	ur->add_undo_method(graph.ptr(),"node_remove",type,newid);
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
 
 }
 
 void ShaderGraphView::_bind_methods() {
 
-        ObjectTypeDB::bind_method("_update_graph",&ShaderGraphView::_update_graph);
-        ObjectTypeDB::bind_method("_begin_node_move", &ShaderGraphView::_begin_node_move);
-        ObjectTypeDB::bind_method("_node_moved",&ShaderGraphView::_node_moved);
-        ObjectTypeDB::bind_method("_end_node_move", &ShaderGraphView::_end_node_move);
-        ObjectTypeDB::bind_method("_move_node",&ShaderGraphView::_move_node);
-        ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
-        ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
-        ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
-
-        ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
-        ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
-        ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
-        ObjectTypeDB::bind_method("_xform_const_changed",&ShaderGraphView::_xform_const_changed);
-        ObjectTypeDB::bind_method("_scalar_op_changed",&ShaderGraphView::_scalar_op_changed);
-        ObjectTypeDB::bind_method("_vec_op_changed",&ShaderGraphView::_vec_op_changed);
-        ObjectTypeDB::bind_method("_vec_scalar_op_changed",&ShaderGraphView::_vec_scalar_op_changed);
-        ObjectTypeDB::bind_method("_rgb_op_changed",&ShaderGraphView::_rgb_op_changed);
-        ObjectTypeDB::bind_method("_xform_inv_rev_changed",&ShaderGraphView::_xform_inv_rev_changed);
-        ObjectTypeDB::bind_method("_scalar_func_changed",&ShaderGraphView::_scalar_func_changed);
-        ObjectTypeDB::bind_method("_vec_func_changed",&ShaderGraphView::_vec_func_changed);
-        ObjectTypeDB::bind_method("_scalar_input_changed",&ShaderGraphView::_scalar_input_changed);
-        ObjectTypeDB::bind_method("_vec_input_changed",&ShaderGraphView::_vec_input_changed);
-        ObjectTypeDB::bind_method("_xform_input_changed",&ShaderGraphView::_xform_input_changed);
-        ObjectTypeDB::bind_method("_rgb_input_changed",&ShaderGraphView::_rgb_input_changed);
-        ObjectTypeDB::bind_method("_tex_input_change",&ShaderGraphView::_tex_input_change);
-        ObjectTypeDB::bind_method("_cube_input_change",&ShaderGraphView::_cube_input_change);
-        ObjectTypeDB::bind_method("_input_name_changed",&ShaderGraphView::_input_name_changed);
-        ObjectTypeDB::bind_method("_tex_edited",&ShaderGraphView::_tex_edited);
-        ObjectTypeDB::bind_method("_variant_edited",&ShaderGraphView::_variant_edited);
-        ObjectTypeDB::bind_method("_cube_edited",&ShaderGraphView::_cube_edited);
-        ObjectTypeDB::bind_method("_comment_edited",&ShaderGraphView::_comment_edited);
-        ObjectTypeDB::bind_method("_color_ramp_changed",&ShaderGraphView::_color_ramp_changed);
-        ObjectTypeDB::bind_method("_curve_changed",&ShaderGraphView::_curve_changed);
-
-        ObjectTypeDB::bind_method("_sg_updated",&ShaderGraphView::_sg_updated);
+	ObjectTypeDB::bind_method("_update_graph",&ShaderGraphView::_update_graph);
+	ObjectTypeDB::bind_method("_begin_node_move", &ShaderGraphView::_begin_node_move);
+	ObjectTypeDB::bind_method("_node_moved",&ShaderGraphView::_node_moved);
+	ObjectTypeDB::bind_method("_end_node_move", &ShaderGraphView::_end_node_move);
+	ObjectTypeDB::bind_method("_move_node",&ShaderGraphView::_move_node);
+	ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
+	ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
+	ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
+
+	ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
+	ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
+	ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
+	ObjectTypeDB::bind_method("_xform_const_changed",&ShaderGraphView::_xform_const_changed);
+	ObjectTypeDB::bind_method("_scalar_op_changed",&ShaderGraphView::_scalar_op_changed);
+	ObjectTypeDB::bind_method("_vec_op_changed",&ShaderGraphView::_vec_op_changed);
+	ObjectTypeDB::bind_method("_vec_scalar_op_changed",&ShaderGraphView::_vec_scalar_op_changed);
+	ObjectTypeDB::bind_method("_rgb_op_changed",&ShaderGraphView::_rgb_op_changed);
+	ObjectTypeDB::bind_method("_xform_inv_rev_changed",&ShaderGraphView::_xform_inv_rev_changed);
+	ObjectTypeDB::bind_method("_scalar_func_changed",&ShaderGraphView::_scalar_func_changed);
+	ObjectTypeDB::bind_method("_vec_func_changed",&ShaderGraphView::_vec_func_changed);
+	ObjectTypeDB::bind_method("_scalar_input_changed",&ShaderGraphView::_scalar_input_changed);
+	ObjectTypeDB::bind_method("_vec_input_changed",&ShaderGraphView::_vec_input_changed);
+	ObjectTypeDB::bind_method("_xform_input_changed",&ShaderGraphView::_xform_input_changed);
+	ObjectTypeDB::bind_method("_rgb_input_changed",&ShaderGraphView::_rgb_input_changed);
+	ObjectTypeDB::bind_method("_tex_input_change",&ShaderGraphView::_tex_input_change);
+	ObjectTypeDB::bind_method("_cube_input_change",&ShaderGraphView::_cube_input_change);
+	ObjectTypeDB::bind_method("_input_name_changed",&ShaderGraphView::_input_name_changed);
+	ObjectTypeDB::bind_method("_tex_edited",&ShaderGraphView::_tex_edited);
+	ObjectTypeDB::bind_method("_variant_edited",&ShaderGraphView::_variant_edited);
+	ObjectTypeDB::bind_method("_cube_edited",&ShaderGraphView::_cube_edited);
+	ObjectTypeDB::bind_method("_comment_edited",&ShaderGraphView::_comment_edited);
+	ObjectTypeDB::bind_method("_color_ramp_changed",&ShaderGraphView::_color_ramp_changed);
+	ObjectTypeDB::bind_method("_curve_changed",&ShaderGraphView::_curve_changed);
+
+	ObjectTypeDB::bind_method("_sg_updated",&ShaderGraphView::_sg_updated);
 }
 
 ShaderGraphView::ShaderGraphView(ShaderGraph::ShaderType p_type) {
 
-        type=p_type;
-        graph_edit = memnew( GraphEdit );
-        block_update=false;
-        ped_popup = memnew( CustomPropertyEditor );
-        graph_edit->add_child(ped_popup);
-        status = memnew( Label );
-        graph_edit->get_top_layer()->add_child(status);
-        graph_edit->connect("_begin_node_move", this, "_begin_node_move");
-        graph_edit->connect("_end_node_move", this, "_end_node_move");
-        status->set_pos(Vector2(5,5));
-        status->add_color_override("font_color_shadow",Color(0,0,0));
-        status->add_color_override("font_color",Color(1,0.4,0.3));
-        status->add_constant_override("shadow_as_outline",1);
-        status->add_constant_override("shadow_offset_x",2);
-        status->add_constant_override("shadow_offset_y",2);
-        status->set_text("");
+	type=p_type;
+	graph_edit = memnew( GraphEdit );
+	block_update=false;
+	ped_popup = memnew( CustomPropertyEditor );
+	graph_edit->add_child(ped_popup);
+	status = memnew( Label );
+	graph_edit->get_top_layer()->add_child(status);
+	graph_edit->connect("_begin_node_move", this, "_begin_node_move");
+	graph_edit->connect("_end_node_move", this, "_end_node_move");
+	status->set_pos(Vector2(5,5));
+	status->add_color_override("font_color_shadow",Color(0,0,0));
+	status->add_color_override("font_color",Color(1,0.4,0.3));
+	status->add_constant_override("shadow_as_outline",1);
+	status->add_constant_override("shadow_offset_x",2);
+	status->add_constant_override("shadow_offset_y",2);
+	status->set_text("");
 }
 
 
 //////////////edit//////////////
 void ShaderGraphEditor::edit(Ref<ShaderGraph> p_shader) {
 
-        for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
-                graph_edits[i]->set_graph(p_shader);
-        }
+	for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
+		graph_edits[i]->set_graph(p_shader);
+	}
 }
 
 void ShaderGraphEditor::_add_node(int p_type) {
 
-        ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
+	ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
 
-        graph_edits[shader_type]->add_node(p_type, next_location);
+	graph_edits[shader_type]->add_node(p_type, next_location);
 }
 
 void ShaderGraphEditor::_popup_requested(const Vector2 &p_position)
 {
-        next_location = get_local_mouse_pos();
-        popup->set_global_pos(p_position);
-        popup->set_size( Size2( 200, 0) );
-        popup->popup();
-        popup->call_deferred("grab_click_focus");
-        popup->set_invalidate_click_until_motion();
+	next_location = get_local_mouse_pos();
+	popup->set_global_pos(p_position);
+	popup->set_size( Size2( 200, 0) );
+	popup->popup();
+	popup->call_deferred("grab_click_focus");
+	popup->set_invalidate_click_until_motion();
 }
 
 
 void ShaderGraphEditor::_notification(int p_what) {
-        if (p_what==NOTIFICATION_ENTER_TREE) {
+	if (p_what==NOTIFICATION_ENTER_TREE) {
 
-                for(int i=0;i<ShaderGraph::NODE_TYPE_MAX;i++) {
+		for(int i=0;i<ShaderGraph::NODE_TYPE_MAX;i++) {
 
-                        if (i==ShaderGraph::NODE_OUTPUT)
-                                continue;
-                        if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
-                                continue;
+			if (i==ShaderGraph::NODE_OUTPUT)
+				continue;
+			if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
+				continue;
 
-                        String nn = node_names[i];
-                        String ic = nn.get_slice(":",0);
-                        String v = nn.get_slice(":",1);
-                        bool addsep=false;
-                        if (nn.ends_with(":")) {
-                                addsep=true;
-                        }
-                        popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
-                        if (addsep)
-                                popup->add_separator();
-                }
-                popup->connect("item_pressed",this,"_add_node");
+			String nn = node_names[i];
+			String ic = nn.get_slice(":",0);
+			String v = nn.get_slice(":",1);
+			bool addsep=false;
+			if (nn.ends_with(":")) {
+				addsep=true;
+			}
+			popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
+			if (addsep)
+				popup->add_separator();
+		}
+		popup->connect("item_pressed",this,"_add_node");
 
 
-        }
+	}
 }
 
 void ShaderGraphEditor::_bind_methods() {
 
-        ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
-        ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
+	ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
+	ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
 }
 
 
 const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
-        "GraphInput:Input", // all inputs (shader type dependent)
-        "GraphScalar:Scalar Constant", //scalar constant
-        "GraphVector:Vector Constant", //vec3 constant
-        "GraphRgb:RGB Constant", //rgb constant (shows a color picker instead)
-        "GraphXform:XForm Constant", // 4x4 matrix constant
-        "GraphTime:Time:", // time in seconds
-        "GraphTexscreen:Screen Sample", // screen texture sampler (takes uv) (only usable in fragment shader)
-        "GraphScalarOp:Scalar Operator", // scalar vs scalar op (mul", add", div", etc)
-        "GraphVecOp:Vector Operator", // vec3 vs vec3 op (mul",ad",div",crossprod",etc)
-        "GraphVecScalarOp:Scalar+Vector Operator", // vec3 vs scalar op (mul", add", div", etc)
-        "GraphRgbOp:RGB Operator:", // vec3 vs vec3 rgb op (with scalar amount)", like brighten", darken", burn", dodge", multiply", etc.
-        "GraphXformMult:XForm Multiply", // mat4 x mat4
-        "GraphXformVecMult:XForm+Vector Multiply", // mat4 x vec3 mult (with no-translation option)
-        "GraphXformVecImult:Form+Vector InvMultiply:", // mat4 x vec3 inverse mult (with no-translation option)
-        "GraphXformScalarFunc:Scalar Function", // scalar function (sin", cos", etc)
-        "GraphXformVecFunc:Vector Function", // vector function (normalize", negate", reciprocal", rgb2hsv", hsv2rgb", etc", etc)
-        "GraphVecLength:Vector Length", // vec3 length
-        "GraphVecDp:Dot Product:", // vec3 . vec3 (dot product -> scalar output)
-        "GraphVecToScalars:Vector -> Scalars", // 1 vec3 input", 3 scalar outputs
-        "GraphScalarsToVec:Scalars -> Vector", // 3 scalar input", 1 vec3 output
-        "GraphXformToVecs:XForm -> Vectors", // 3 vec input", 1 xform output
-        "GraphVecsToXform:Vectors -> XForm:", // 3 vec input", 1 xform output
-        "GraphScalarInterp:Scalar Interpolate", // scalar interpolation (with optional curve)
-        "GraphVecInterp:Vector Interpolate:", // vec3 interpolation  (with optional curve)
-        "GraphColorRamp:Color Ramp", // vec3 interpolation  (with optional curve)
-        "GraphCurveMap:Curve Remap:", // vec3 interpolation  (with optional curve)
-        "GraphScalarUniform:Scalar Uniform", // scalar uniform (assignable in material)
-        "GraphVectorUniform:Vector Uniform", // vec3 uniform (assignable in material)
-        "GraphRgbUniform:RGB Uniform", // color uniform (assignable in material)
-        "GraphXformUniform:XForm Uniform", // mat4 uniform (assignable in material)
-        "GraphTextureUniform:Texture Uniform", // texture input (assignable in material)
-        "GraphCubeUniform:CubeMap Uniform:", // cubemap input (assignable in material)
-        "GraphDefaultTexture:CanvasItem Texture:", // cubemap input (assignable in material)
-        "Output", // output (shader type dependent)
-        "GraphComment:Comment", // comment
+	"GraphInput:Input", // all inputs (shader type dependent)
+	"GraphScalar:Scalar Constant", //scalar constant
+	"GraphVector:Vector Constant", //vec3 constant
+	"GraphRgb:RGB Constant", //rgb constant (shows a color picker instead)
+	"GraphXform:XForm Constant", // 4x4 matrix constant
+	"GraphTime:Time:", // time in seconds
+	"GraphTexscreen:Screen Sample", // screen texture sampler (takes uv) (only usable in fragment shader)
+	"GraphScalarOp:Scalar Operator", // scalar vs scalar op (mul", add", div", etc)
+	"GraphVecOp:Vector Operator", // vec3 vs vec3 op (mul",ad",div",crossprod",etc)
+	"GraphVecScalarOp:Scalar+Vector Operator", // vec3 vs scalar op (mul", add", div", etc)
+	"GraphRgbOp:RGB Operator:", // vec3 vs vec3 rgb op (with scalar amount)", like brighten", darken", burn", dodge", multiply", etc.
+	"GraphXformMult:XForm Multiply", // mat4 x mat4
+	"GraphXformVecMult:XForm+Vector Multiply", // mat4 x vec3 mult (with no-translation option)
+	"GraphXformVecImult:Form+Vector InvMultiply:", // mat4 x vec3 inverse mult (with no-translation option)
+	"GraphXformScalarFunc:Scalar Function", // scalar function (sin", cos", etc)
+	"GraphXformVecFunc:Vector Function", // vector function (normalize", negate", reciprocal", rgb2hsv", hsv2rgb", etc", etc)
+	"GraphVecLength:Vector Length", // vec3 length
+	"GraphVecDp:Dot Product:", // vec3 . vec3 (dot product -> scalar output)
+	"GraphVecToScalars:Vector -> Scalars", // 1 vec3 input", 3 scalar outputs
+	"GraphScalarsToVec:Scalars -> Vector", // 3 scalar input", 1 vec3 output
+	"GraphXformToVecs:XForm -> Vectors", // 3 vec input", 1 xform output
+	"GraphVecsToXform:Vectors -> XForm:", // 3 vec input", 1 xform output
+	"GraphScalarInterp:Scalar Interpolate", // scalar interpolation (with optional curve)
+	"GraphVecInterp:Vector Interpolate:", // vec3 interpolation  (with optional curve)
+	"GraphColorRamp:Color Ramp", // vec3 interpolation  (with optional curve)
+	"GraphCurveMap:Curve Remap:", // vec3 interpolation  (with optional curve)
+	"GraphScalarUniform:Scalar Uniform", // scalar uniform (assignable in material)
+	"GraphVectorUniform:Vector Uniform", // vec3 uniform (assignable in material)
+	"GraphRgbUniform:RGB Uniform", // color uniform (assignable in material)
+	"GraphXformUniform:XForm Uniform", // mat4 uniform (assignable in material)
+	"GraphTextureUniform:Texture Uniform", // texture input (assignable in material)
+	"GraphCubeUniform:CubeMap Uniform:", // cubemap input (assignable in material)
+	"GraphDefaultTexture:CanvasItem Texture:", // cubemap input (assignable in material)
+	"Output", // output (shader type dependent)
+	"GraphComment:Comment", // comment
 
 
 };
 ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
-        _2d=p_2d;
+	_2d=p_2d;
 
-        HBoxContainer *hbc = memnew( HBoxContainer );
-        popup = memnew( PopupMenu );
-        hbc->add_child(popup);
-        add_child(hbc);
+	HBoxContainer *hbc = memnew( HBoxContainer );
+	popup = memnew( PopupMenu );
+	hbc->add_child(popup);
+	add_child(hbc);
 
 
-        tabs = memnew(TabContainer);
-        tabs->set_v_size_flags(SIZE_EXPAND_FILL);
-        add_child(tabs);
-        const char* sname[ShaderGraph::SHADER_TYPE_MAX]={
-                "Vertex",
-                "Fragment",
-                "Light"
-        };
-        for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
+	tabs = memnew(TabContainer);
+	tabs->set_v_size_flags(SIZE_EXPAND_FILL);
+	add_child(tabs);
+	const char* sname[ShaderGraph::SHADER_TYPE_MAX]={
+		"Vertex",
+		"Fragment",
+		"Light"
+	};
+	for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
 
-                graph_edits[i]= memnew( ShaderGraphView(ShaderGraph::ShaderType(i)) );
-                add_child(graph_edits[i]);
-                graph_edits[i]->get_graph_edit()->set_name(sname[i]);
-                tabs->add_child(graph_edits[i]->get_graph_edit());
-                graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
-                graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
-                graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
-                graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
-        }
+		graph_edits[i]= memnew( ShaderGraphView(ShaderGraph::ShaderType(i)) );
+		add_child(graph_edits[i]);
+		graph_edits[i]->get_graph_edit()->set_name(sname[i]);
+		tabs->add_child(graph_edits[i]->get_graph_edit());
+		graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
+		graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
+		graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
+		graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
+	}
 
-        tabs->set_current_tab(1);
+	tabs->set_current_tab(1);
 
-        set_custom_minimum_size(Size2(100,300));
+	set_custom_minimum_size(Size2(100,300));
 }
 
 
 void ShaderGraphEditorPlugin::edit(Object *p_object) {
 
-        shader_editor->edit(p_object->cast_to<ShaderGraph>());
+	shader_editor->edit(p_object->cast_to<ShaderGraph>());
 }
 
 bool ShaderGraphEditorPlugin::handles(Object *p_object) const {
 
-        ShaderGraph *shader=p_object->cast_to<ShaderGraph>();
-        if (!shader)
-                return false;
-        if (_2d)
-                return shader->get_mode()==Shader::MODE_CANVAS_ITEM;
-        else
-                return shader->get_mode()==Shader::MODE_MATERIAL;
+	ShaderGraph *shader=p_object->cast_to<ShaderGraph>();
+	if (!shader)
+		return false;
+	if (_2d)
+		return shader->get_mode()==Shader::MODE_CANVAS_ITEM;
+	else
+		return shader->get_mode()==Shader::MODE_MATERIAL;
 }
 
 void ShaderGraphEditorPlugin::make_visible(bool p_visible) {
 
-        if (p_visible) {
-                shader_editor->show();
-        } else {
+	if (p_visible) {
+		shader_editor->show();
+	} else {
 
-                shader_editor->hide();
-        }
+		shader_editor->hide();
+	}
 
 }
 
 ShaderGraphEditorPlugin::ShaderGraphEditorPlugin(EditorNode *p_node, bool p_2d) {
 
-        _2d=p_2d;
-        editor=p_node;
-        shader_editor = memnew( ShaderGraphEditor(p_2d) );
-        shader_editor->hide();
-        if (p_2d)
-                CanvasItemEditor::get_singleton()->get_bottom_split()->add_child(shader_editor);
-        else
-                SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);
+	_2d=p_2d;
+	editor=p_node;
+	shader_editor = memnew( ShaderGraphEditor(p_2d) );
+	shader_editor->hide();
+	if (p_2d)
+		CanvasItemEditor::get_singleton()->get_bottom_split()->add_child(shader_editor);
+	else
+		SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);
 
 
-//	editor->get_viewport()->add_child(shader_editor);
-//	shader_editor->set_area_as_parent_rect();
-//	shader_editor->hide();
+	//	editor->get_viewport()->add_child(shader_editor);
+	//	shader_editor->set_area_as_parent_rect();
+	//	shader_editor->hide();
 
 }
 
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index ea21a7706f..5f93b9df7d 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -41,189 +41,189 @@
 #include "tools/editor/property_editor.h"
 #include "scene/resources/shader_graph.h"
 /**
-    @author Juan Linietsky <reduzio@gmail.com>
+	@author Juan Linietsky <reduzio@gmail.com>
 */
 
 
 class GraphColorRampEdit : public Control {
 
-    OBJ_TYPE(GraphColorRampEdit,Control);
+	OBJ_TYPE(GraphColorRampEdit,Control);
 
 
-    struct Point {
+	struct Point {
 
-        float offset;
-        Color color;
-        bool operator<(const Point& p_ponit) const {
-            return offset<p_ponit.offset;
-        }
-    };
+		float offset;
+		Color color;
+		bool operator<(const Point& p_ponit) const {
+			return offset<p_ponit.offset;
+		}
+	};
 
-    PopupPanel *popup;
-    ColorPicker *picker;
+	PopupPanel *popup;
+	ColorPicker *picker;
 
 
-    bool grabbing;
-    int grabbed;
-    float grabbed_at;
-    Vector<Point> points;
+	bool grabbing;
+	int grabbed;
+	float grabbed_at;
+	Vector<Point> points;
 
-    void _color_changed(const Color& p_color);
+	void _color_changed(const Color& p_color);
 
 protected:
-    void _input_event(const InputEvent& p_event);
-    void _notification(int p_what);
-    static void _bind_methods();
+	void _input_event(const InputEvent& p_event);
+	void _notification(int p_what);
+	static void _bind_methods();
 public:
 
-    void set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors);
-    Vector<float> get_offsets() const;
-    Vector<Color> get_colors() const;
-    virtual Size2 get_minimum_size() const;
-    GraphColorRampEdit();
+	void set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors);
+	Vector<float> get_offsets() const;
+	Vector<Color> get_colors() const;
+	virtual Size2 get_minimum_size() const;
+	GraphColorRampEdit();
 };
 
 
 class GraphCurveMapEdit : public Control {
 
-    OBJ_TYPE(GraphCurveMapEdit,Control);
+	OBJ_TYPE(GraphCurveMapEdit,Control);
 
 
-    struct Point {
+	struct Point {
 
-        float offset;
-        float height;
-        bool operator<(const Point& p_ponit) const {
-            return offset<p_ponit.offset;
-        }
-    };
+		float offset;
+		float height;
+		bool operator<(const Point& p_ponit) const {
+			return offset<p_ponit.offset;
+		}
+	};
 
 
-    bool grabbing;
-    int grabbed;
-    Vector<Point> points;
+	bool grabbing;
+	int grabbed;
+	Vector<Point> points;
 
-    void _plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d);
+	void _plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d);
 protected:
-    void _input_event(const InputEvent& p_event);
-    void _notification(int p_what);
-    static void _bind_methods();
+	void _input_event(const InputEvent& p_event);
+	void _notification(int p_what);
+	static void _bind_methods();
 public:
 
-    void set_points(const Vector<Vector2>& p_points);
-    Vector<Vector2> get_points() const;
-    virtual Size2 get_minimum_size() const;
-    GraphCurveMapEdit();
+	void set_points(const Vector<Vector2>& p_points);
+	Vector<Vector2> get_points() const;
+	virtual Size2 get_minimum_size() const;
+	GraphCurveMapEdit();
 };
 
 class ShaderGraphView : public Node {
 
-    OBJ_TYPE(ShaderGraphView,Node);
-
-
-
-    CustomPropertyEditor *ped_popup;
-    bool block_update;
-
-    Label *status;
-    GraphEdit *graph_edit;
-    Ref<ShaderGraph> graph;
-    int edited_id;
-
-    ShaderGraph::ShaderType type;
-
-    void _update_graph();
-    void _create_node(int p_id);
-
-
-
-    void _connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
-    void _disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
-
-    void _node_removed(int p_id);
-    void _begin_node_move();
-    void _node_moved(const Vector2& p_from, const Vector2& p_to,int p_id);
-    void _end_node_move();
-    void _move_node(int p_id,const Vector2& p_to);
-
-    void _scalar_const_changed(double p_value,int p_id);
-    void _vec_const_changed(double p_value, int p_id, Array p_arr);
-    void _rgb_const_changed(const Color& p_color, int p_id);
-    void _xform_const_changed(int p_id,Node* p_button);
-    void _scalar_op_changed(int p_op, int p_id);
-    void _vec_op_changed(int p_op, int p_id);
-    void _vec_scalar_op_changed(int p_op, int p_id);
-    void _rgb_op_changed(int p_op, int p_id);
-    void _xform_inv_rev_changed(bool p_enabled, int p_id);
-    void _scalar_func_changed(int p_func, int p_id);
-    void _vec_func_changed(int p_func, int p_id);
-    void _scalar_input_changed(double p_value,int p_id);
-    void _vec_input_changed(double p_value, int p_id, Array p_arr);
-    void _xform_input_changed(int p_id,Node* p_button);
-    void _rgb_input_changed(const Color& p_color, int p_id);
-    void _tex_input_change(int p_id,Node* p_button);
-    void _cube_input_change(int p_id);
-    void _input_name_changed(const String& p_name,int p_id,Node* p_line_edit);
-    void _tex_edited(int p_id,Node* p_button);
-    void _cube_edited(int p_id,Node* p_button);
-    void _variant_edited();
-    void _comment_edited(int p_id,Node* p_button);
-    void _color_ramp_changed(int p_id,Node* p_ramp);
-    void _curve_changed(int p_id,Node* p_curve);
-    void _sg_updated();
-    Map<int,GraphNode*> node_map;
+	OBJ_TYPE(ShaderGraphView,Node);
+
+
+
+	CustomPropertyEditor *ped_popup;
+	bool block_update;
+
+	Label *status;
+	GraphEdit *graph_edit;
+	Ref<ShaderGraph> graph;
+	int edited_id;
+
+	ShaderGraph::ShaderType type;
+
+	void _update_graph();
+	void _create_node(int p_id);
+
+
+
+	void _connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
+	void _disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
+
+	void _node_removed(int p_id);
+	void _begin_node_move();
+	void _node_moved(const Vector2& p_from, const Vector2& p_to,int p_id);
+	void _end_node_move();
+	void _move_node(int p_id,const Vector2& p_to);
+
+	void _scalar_const_changed(double p_value,int p_id);
+	void _vec_const_changed(double p_value, int p_id, Array p_arr);
+	void _rgb_const_changed(const Color& p_color, int p_id);
+	void _xform_const_changed(int p_id,Node* p_button);
+	void _scalar_op_changed(int p_op, int p_id);
+	void _vec_op_changed(int p_op, int p_id);
+	void _vec_scalar_op_changed(int p_op, int p_id);
+	void _rgb_op_changed(int p_op, int p_id);
+	void _xform_inv_rev_changed(bool p_enabled, int p_id);
+	void _scalar_func_changed(int p_func, int p_id);
+	void _vec_func_changed(int p_func, int p_id);
+	void _scalar_input_changed(double p_value,int p_id);
+	void _vec_input_changed(double p_value, int p_id, Array p_arr);
+	void _xform_input_changed(int p_id,Node* p_button);
+	void _rgb_input_changed(const Color& p_color, int p_id);
+	void _tex_input_change(int p_id,Node* p_button);
+	void _cube_input_change(int p_id);
+	void _input_name_changed(const String& p_name,int p_id,Node* p_line_edit);
+	void _tex_edited(int p_id,Node* p_button);
+	void _cube_edited(int p_id,Node* p_button);
+	void _variant_edited();
+	void _comment_edited(int p_id,Node* p_button);
+	void _color_ramp_changed(int p_id,Node* p_ramp);
+	void _curve_changed(int p_id,Node* p_curve);
+	void _sg_updated();
+	Map<int,GraphNode*> node_map;
 protected:
-    void _notification(int p_what);
-    static void _bind_methods();
+	void _notification(int p_what);
+	static void _bind_methods();
 public:
 
-    void add_node(int p_type, const Vector2 &location);
-    GraphEdit *get_graph_edit() { return graph_edit; }
-    void set_graph(Ref<ShaderGraph> p_graph);
+	void add_node(int p_type, const Vector2 &location);
+	GraphEdit *get_graph_edit() { return graph_edit; }
+	void set_graph(Ref<ShaderGraph> p_graph);
 
-    ShaderGraphView(ShaderGraph::ShaderType p_type=ShaderGraph::SHADER_TYPE_FRAGMENT);
+	ShaderGraphView(ShaderGraph::ShaderType p_type=ShaderGraph::SHADER_TYPE_FRAGMENT);
 };
 
 class ShaderGraphEditor : public VBoxContainer {
 
-    OBJ_TYPE(ShaderGraphEditor,VBoxContainer);
+	OBJ_TYPE(ShaderGraphEditor,VBoxContainer);
 
-    PopupMenu *popup;
-    TabContainer *tabs;
-    ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
-    static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
-    Vector2 next_location;
+	PopupMenu *popup;
+	TabContainer *tabs;
+	ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
+	static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
+	Vector2 next_location;
 
-    bool _2d;
-    void _add_node(int p_type);
-    void _popup_requested(const Vector2 &p_position);
+	bool _2d;
+	void _add_node(int p_type);
+	void _popup_requested(const Vector2 &p_position);
 protected:
-    void _notification(int p_what);
-    static void _bind_methods();
+	void _notification(int p_what);
+	static void _bind_methods();
 public:
 
-    void edit(Ref<ShaderGraph> p_shader);
-    ShaderGraphEditor(bool p_2d);
+	void edit(Ref<ShaderGraph> p_shader);
+	ShaderGraphEditor(bool p_2d);
 };
 
 class ShaderGraphEditorPlugin : public EditorPlugin {
 
-    OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin );
+	OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin );
 
-    bool _2d;
-    ShaderGraphEditor *shader_editor;
-    EditorNode *editor;
+	bool _2d;
+	ShaderGraphEditor *shader_editor;
+	EditorNode *editor;
 
 public:
 
-    virtual String get_name() const { return "ShaderGraph"; }
-    bool has_main_screen() const { return false; }
-    virtual void edit(Object *p_node);
-    virtual bool handles(Object *p_node) const;
-    virtual void make_visible(bool p_visible);
+	virtual String get_name() const { return "ShaderGraph"; }
+	bool has_main_screen() const { return false; }
+	virtual void edit(Object *p_node);
+	virtual bool handles(Object *p_node) const;
+	virtual void make_visible(bool p_visible);
 
-    ShaderGraphEditorPlugin(EditorNode *p_node,bool p_2d);
-    ~ShaderGraphEditorPlugin();
+	ShaderGraphEditorPlugin(EditorNode *p_node,bool p_2d);
+	~ShaderGraphEditorPlugin();
 
 };
 #endif
-- 
cgit v1.2.3


From 5ffd818fb195a6e9bea48ec03ad52a77080a8d25 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sat, 25 Jul 2015 21:16:07 -0300
Subject: Duplicate GraphNode(s) [Control+D]

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 43 ++++++++++++++++++++--
 tools/editor/plugins/shader_graph_editor_plugin.h  |  2 +
 2 files changed, 42 insertions(+), 3 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 6e95432b99..3ab536ab6e 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -1184,6 +1184,43 @@ void ShaderGraphView::_move_node(int p_id,const Vector2& p_to) {
 	graph->node_set_pos(type,p_id,p_to);
 }
 
+void ShaderGraphView::_duplicate_nodes_request()
+{
+	Array s_id;
+
+	for(Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+		ShaderGraph::NodeType t=graph->node_get_type(type, E->key());
+		if (t==ShaderGraph::NODE_OUTPUT || t==ShaderGraph::NODE_INPUT)
+			continue;
+		GraphNode *gn = E->get();
+		if (gn && gn->is_selected())
+			s_id.push_back(E->key());
+	}
+
+	if (s_id.size()==0)
+		return;
+
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Duplicate Graph Node(s)");
+	ur->add_do_method(this,"_duplicate_nodes",s_id);
+	List<int> n_ids = graph->generate_ids(type, s_id.size());
+	for (List<int>::Element *E=n_ids.front();E;E=E->next())
+		ur->add_undo_method(graph.ptr(),"node_remove",type,E->get());
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
+
+}
+
+void ShaderGraphView::_duplicate_nodes(Array &p_nodes)
+{
+	List<int> n = List<int>();
+	for (int i=0; i<p_nodes.size();i++)
+		n.push_back(p_nodes.get(i));
+	graph->duplicate_nodes(type, n);
+	call_deferred("_update_graph");
+}
+
 
 void ShaderGraphView::_create_node(int p_id) {
 
@@ -2087,8 +2124,6 @@ void ShaderGraphView::_update_graph() {
 		graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
 	}
 
-
-
 }
 
 void ShaderGraphView::_sg_updated() {
@@ -2175,6 +2210,8 @@ void ShaderGraphView::_bind_methods() {
 	ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
 	ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
 	ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
+	ObjectTypeDB::bind_method("_duplicate_nodes_request", &ShaderGraphView::_duplicate_nodes_request);
+	ObjectTypeDB::bind_method("_duplicate_nodes", &ShaderGraphView::_duplicate_nodes);
 
 	ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
 	ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
@@ -2250,7 +2287,6 @@ void ShaderGraphEditor::_popup_requested(const Vector2 &p_position)
 	popup->set_invalidate_click_until_motion();
 }
 
-
 void ShaderGraphEditor::_notification(int p_what) {
 	if (p_what==NOTIFICATION_ENTER_TREE) {
 
@@ -2349,6 +2385,7 @@ ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
 		tabs->add_child(graph_edits[i]->get_graph_edit());
 		graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
 		graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
+		graph_edits[i]->get_graph_edit()->connect("duplicate_nodes_request", graph_edits[i], "_duplicate_nodes_request");
 		graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
 		graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
 	}
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index 5f93b9df7d..faf6d7d64e 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -145,6 +145,8 @@ class ShaderGraphView : public Node {
 	void _node_moved(const Vector2& p_from, const Vector2& p_to,int p_id);
 	void _end_node_move();
 	void _move_node(int p_id,const Vector2& p_to);
+	void _duplicate_nodes_request();
+	void _duplicate_nodes(Array &p_nodes);
 
 	void _scalar_const_changed(double p_value,int p_id);
 	void _vec_const_changed(double p_value, int p_id, Array p_arr);
-- 
cgit v1.2.3


From add0105c4e89e586fb3d3a9646a9ffc747d2e881 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sat, 25 Jul 2015 22:05:45 -0300
Subject: Little fix: don't create an empty undo/redo command when trying to
 add a second Input GraphNode

---
 tools/editor/plugins/shader_graph_editor_plugin.cpp | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 3ab536ab6e..370688d6f5 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -2162,6 +2162,9 @@ void ShaderGraphView::_notification(int p_what) {
 
 void ShaderGraphView::add_node(int p_type, const Vector2 &location) {
 
+	if ((p_type==ShaderGraph::NODE_INPUT||p_type==ShaderGraph::NODE_INPUT) && graph->node_count(type, p_type)>0)
+		return;
+
 	List<int> existing;
 	graph->get_node_list(type,&existing);
 	existing.sort();
-- 
cgit v1.2.3


From d7279ddaf2aa98ed962d84d466f21dc2f39522c9 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sun, 26 Jul 2015 21:57:27 -0300
Subject: Delete selected nodes with the Delete key

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 41 ++++++++++++++++++++++
 tools/editor/plugins/shader_graph_editor_plugin.h  |  1 +
 2 files changed, 42 insertions(+)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 370688d6f5..b2de10ca20 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -1221,6 +1221,45 @@ void ShaderGraphView::_duplicate_nodes(Array &p_nodes)
 	call_deferred("_update_graph");
 }
 
+void ShaderGraphView::_delete_nodes_request()
+{
+	List<int> s_id=List<int>();
+
+	for(Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
+		ShaderGraph::NodeType t=graph->node_get_type(type, E->key());
+		if (t==ShaderGraph::NODE_OUTPUT)
+			continue;
+		GraphNode *gn = E->get();
+		if (gn && gn->is_selected())
+			s_id.push_back(E->key());
+	}
+
+	if (s_id.size()==0)
+		return;
+
+	UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+	ur->create_action("Delete Shader Graph Node(s)");
+
+	for (List<int>::Element *N=s_id.front();N;N=N->next()) {
+		ur->add_do_method(graph.ptr(),"node_remove",type,N->get());
+		ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,N->get()),N->get());
+		ur->add_undo_method(graph.ptr(),"node_set_state",type,N->get(),graph->node_get_state(type,N->get()));
+		List<ShaderGraph::Connection> conns;
+
+		graph->get_node_connections(type,&conns);
+		for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
+
+			if (E->get().dst_id==N->get() || E->get().src_id==N->get()) {
+				ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
+			}
+		}
+	}
+	ur->add_do_method(this,"_update_graph");
+	ur->add_undo_method(this,"_update_graph");
+	ur->commit_action();
+
+}
+
 
 void ShaderGraphView::_create_node(int p_id) {
 
@@ -2215,6 +2254,7 @@ void ShaderGraphView::_bind_methods() {
 	ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
 	ObjectTypeDB::bind_method("_duplicate_nodes_request", &ShaderGraphView::_duplicate_nodes_request);
 	ObjectTypeDB::bind_method("_duplicate_nodes", &ShaderGraphView::_duplicate_nodes);
+	ObjectTypeDB::bind_method("_delete_nodes_request", &ShaderGraphView::_delete_nodes_request);
 
 	ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
 	ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
@@ -2390,6 +2430,7 @@ ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
 		graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
 		graph_edits[i]->get_graph_edit()->connect("duplicate_nodes_request", graph_edits[i], "_duplicate_nodes_request");
 		graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
+		graph_edits[i]->get_graph_edit()->connect("delete_nodes_request",graph_edits[i],"_delete_nodes_request");
 		graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
 	}
 
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index faf6d7d64e..36443efeb0 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -147,6 +147,7 @@ class ShaderGraphView : public Node {
 	void _move_node(int p_id,const Vector2& p_to);
 	void _duplicate_nodes_request();
 	void _duplicate_nodes(Array &p_nodes);
+	void _delete_nodes_request();
 
 	void _scalar_const_changed(double p_value,int p_id);
 	void _vec_const_changed(double p_value, int p_id, Array p_arr);
-- 
cgit v1.2.3


From ea448cb779c9268f6213a8e741cfc793704ca2fe Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sat, 29 Aug 2015 21:09:11 -0300
Subject: Edit default values. WARNING!!! Do not merge these changes, default
 values are not compiled into shaders yet!

---
 .../editor/plugins/shader_graph_editor_plugin.cpp  | 437 ++++++++++++++--
 tools/editor/plugins/shader_graph_editor_plugin.h  |   6 +
 tools/editor/property_editor.cpp                   | 561 ++++++++++++---------
 tools/editor/property_editor.h                     |  46 +-
 4 files changed, 727 insertions(+), 323 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index b2de10ca20..12a9dce6b7 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -29,6 +29,7 @@
 #include "shader_graph_editor_plugin.h"
 
 
+#include "scene/gui/check_box.h"
 #include "scene/gui/menu_button.h"
 #include "scene/gui/panel.h"
 #include "spatial_editor_plugin.h"
@@ -840,6 +841,7 @@ void ShaderGraphView::_xform_input_changed(int p_id, Node *p_button){
 	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
 	ped_popup->set_size(tb->get_size());
 	edited_id=p_id;
+	edited_def=-1;
 	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
 	ped_popup->popup();
 
@@ -850,6 +852,7 @@ void ShaderGraphView::_xform_const_changed(int p_id, Node *p_button){
 	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
 	ped_popup->set_size(tb->get_size());
 	edited_id=p_id;
+	edited_def=-1;
 	ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
 	ped_popup->popup();
 
@@ -879,6 +882,35 @@ void ShaderGraphView::_cube_input_change(int p_id){
 
 void ShaderGraphView::_variant_edited() {
 
+	if (edited_def != -1) {
+
+		Variant v = ped_popup->get_variant();
+		Variant v2 = graph->default_get_value(type,edited_id,edited_def);
+		if (v2.get_type() == Variant::NIL)
+			switch (v.get_type()) {
+			case Variant::VECTOR3:
+				v2=Vector3();
+				break;
+			case Variant::REAL:
+				v2=0.0;
+				break;
+			case Variant::TRANSFORM:
+				v2=Transform();
+				break;
+			case Variant::COLOR:
+				v2=Color();
+				break;
+			}
+		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
+		ur->create_action("Change default value");
+		ur->add_do_method(graph.ptr(),"default_set_value",type,edited_id,edited_def, v);
+		ur->add_undo_method(graph.ptr(),"default_set_value",type,edited_id,edited_def, v2);
+		ur->add_do_method(this,"_update_graph");
+		ur->add_undo_method(this,"_update_graph");
+		ur->commit_action();
+		return;
+	}
+
 	if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
 
 		UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
@@ -1043,6 +1075,7 @@ void ShaderGraphView::_tex_edited(int p_id,Node* p_button) {
 	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
 	ped_popup->set_size(tb->get_size());
 	edited_id=p_id;
+	edited_def=-1;
 	ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
 }
 
@@ -1052,6 +1085,7 @@ void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
 	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
 	ped_popup->set_size(tb->get_size());
 	edited_id=p_id;
+	edited_def=-1;
 	ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
 }
 
@@ -1260,6 +1294,97 @@ void ShaderGraphView::_delete_nodes_request()
 
 }
 
+void ShaderGraphView::_default_changed(int p_id, Node *p_button, int p_param, int v_type, String p_hint)
+{
+	ToolButton *tb = p_button->cast_to<ToolButton>();
+	ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
+	ped_popup->set_size(tb->get_size());
+	edited_id=p_id;
+	edited_def=p_param;
+	Variant::Type vt = (Variant::Type)v_type;
+	Variant v = graph->default_get_value(type,p_id,edited_def);
+	int h=PROPERTY_HINT_NONE;
+	if (v.get_type() == Variant::NIL)
+		switch (vt) {
+		case Variant::VECTOR3:
+			v=Vector3();
+			break;
+		case Variant::REAL:
+			h=PROPERTY_HINT_RANGE;
+			v=0.0;
+			break;
+		case Variant::TRANSFORM:
+			v=Transform();
+			break;
+		case Variant::COLOR:
+			h=PROPERTY_HINT_COLOR_NO_ALPHA;
+			v=Color();
+			break;
+		}
+
+	ped_popup->edit(NULL,"",vt,v,h,p_hint);
+
+	ped_popup->popup();
+}
+
+ToolButton *ShaderGraphView::make_label(String text, Variant::Type v_type) {
+	ToolButton *l = memnew( ToolButton );
+	l->set_text(text);
+	l->set_text_align(ToolButton::ALIGN_LEFT);
+	l->add_style_override("hover", l->get_stylebox("normal", "ToolButton"));
+	l->add_style_override("pressed", l->get_stylebox("normal", "ToolButton"));
+	l->add_style_override("focus", l->get_stylebox("normal", "ToolButton"));
+	switch (v_type) {
+	case Variant::REAL:
+		l->set_icon(ped_popup->get_icon("Real", "EditorIcons"));
+		break;
+	case Variant::VECTOR3:
+		l->set_icon(ped_popup->get_icon("Vector", "EditorIcons"));
+		break;
+	case Variant::TRANSFORM:
+		l->set_icon(ped_popup->get_icon("Matrix", "EditorIcons"));
+		break;
+	case Variant::COLOR:
+		l->set_icon(ped_popup->get_icon("Color", "EditorIcons"));
+	}
+	return l;
+}
+
+ToolButton *ShaderGraphView::make_editor(String text,GraphNode* gn,int p_id,int param,Variant::Type v_type, String p_hint) {
+	ToolButton *edit = memnew( ToolButton );
+	edit->set_text(text);
+	edit->set_text_align(ToolButton::ALIGN_LEFT);
+	edit->set_flat(false);
+	edit->add_style_override("normal", gn->get_stylebox("defaultframe", "GraphNode"));
+	edit->add_style_override("hover", gn->get_stylebox("defaultframe", "GraphNode"));
+	edit->add_style_override("pressed", gn->get_stylebox("defaultframe", "GraphNode"));
+	edit->add_style_override("focus", gn->get_stylebox("defaultfocus", "GraphNode"));
+	edit->connect("pressed",this,"_default_changed",varray(p_id,edit,param,v_type,p_hint));
+
+	switch (v_type) {
+	case Variant::REAL:
+		edit->set_icon(ped_popup->get_icon("Real", "EditorIcons"));
+		break;
+	case Variant::VECTOR3:
+		edit->set_icon(ped_popup->get_icon("Vector", "EditorIcons"));
+		break;
+	case Variant::TRANSFORM:
+		edit->set_icon(ped_popup->get_icon("Matrix", "EditorIcons"));
+		break;
+	case Variant::COLOR:
+		Image icon_color = Image(15,15,false,Image::FORMAT_RGB);
+		Color c = graph->default_get_value(type,p_id,param);
+		for (int x=1;x<14;x++)
+			for (int y=1;y<14;y++)
+				icon_color.put_pixel(x,y,c);
+		Ref<ImageTexture> t;
+		t.instance();
+		t->create_from_image(icon_color);
+		edit->set_icon(t);
+		break;
+	}
+	return edit;
+}
 
 void ShaderGraphView::_create_node(int p_id) {
 
@@ -1273,6 +1398,9 @@ void ShaderGraphView::_create_node(int p_id) {
 		Color(0,1,1)
 	};
 
+	const String hint_spin = "-65536,65535,0.001";
+	const String hint_slider = "0.0,1.0,0.01,slider";
+
 
 	switch(graph->node_get_type(type,p_id)) {
 
@@ -1377,7 +1505,12 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("ScreenTex");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("UV")));
+		if (!graph->is_slot_connected(type,p_id,0)) {
+			Vector3 v = graph->default_get_value(type, p_id, 0);
+			hbc->add_child(make_editor("UV: " + v,gn,p_id,0,Variant::VECTOR3));
+		} else {
+			hbc->add_child(make_label("UV",Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("RGB")));
 		gn->add_child(hbc);
@@ -1411,11 +1544,21 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a",Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b",Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
+		}
 
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
 		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
@@ -1449,11 +1592,21 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a",Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b",Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
+		}
 
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1481,12 +1634,22 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a",Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
 
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b",Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
+		}
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
 
@@ -1519,11 +1682,19 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a",Variant::COLOR));
+		} else {
+			hbc->add_child(make_editor(String("a: "),gn,p_id,0,Variant::COLOR));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b",Variant::COLOR));
+		} else {
+			gn->add_child(make_editor(String("b: "),gn,p_id,1,Variant::COLOR));
+		}
 
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1533,11 +1704,19 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		gn->set_title("XFMult");
 		HBoxContainer *hbc = memnew( HBoxContainer );
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a",Variant::TRANSFORM));
+		} else {
+			hbc->add_child(make_editor(String("a: edit..."),gn,p_id,0,Variant::TRANSFORM));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b",Variant::TRANSFORM));
+		} else {
+			gn->add_child(make_editor(String("b: edit..."),gn,p_id,1,Variant::TRANSFORM));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
@@ -1548,8 +1727,7 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		gn->set_title("XFVecMult");
 
-		Button *button = memnew( Button("RotOnly"));
-		button->set_toggle_mode(true);
+		CheckBox *button = memnew (CheckBox("RotOnly"));
 		button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
 		button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
 
@@ -1557,13 +1735,22 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("xf")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("xf",Variant::TRANSFORM));
+		} else {
+			hbc->add_child(make_editor(String("xf: edit..."),gn,p_id,0,Variant::TRANSFORM));
+		}
 		hbc->add_spacer();
 		Label *l = memnew(Label("out"));
 		l->set_align(Label::ALIGN_RIGHT);
 		hbc->add_child( l);
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("vec")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("a",Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("a: ")+v,gn,p_id,1,Variant::VECTOR3));
+		}
 
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1574,17 +1761,25 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("XFVecInvMult");
 
 
-		Button *button = memnew( Button("RotOnly"));
-		button->set_toggle_mode(true);
+		CheckBox *button = memnew( CheckBox("RotOnly"));
 		button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
 		button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
 
 		gn->add_child(button);
 
-		gn->add_child( memnew(Label("vec")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			gn->add_child(make_label("a",Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			gn->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("xf")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			hbc->add_child(make_label("xf", Variant::TRANSFORM));
+		} else {
+			hbc->add_child(make_editor(String("xf: edit..."),gn,p_id,1,Variant::TRANSFORM));
+		}
 		hbc->add_spacer();
 		Label *l = memnew(Label("out"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -1633,7 +1828,12 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->add_child(ob);
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
-		hbc->add_child( memnew(Label("in")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("in", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("in: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
@@ -1668,7 +1868,12 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("in")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("in", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("in: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("out")));
 		gn->add_child(hbc);
@@ -1679,7 +1884,12 @@ void ShaderGraphView::_create_node(int p_id) {
 	case ShaderGraph::NODE_VEC_LEN: {
 		gn->set_title("VecLength");
 		HBoxContainer *hbc = memnew( HBoxContainer );
-		hbc->add_child( memnew(Label("in")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("in", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("in: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("len")));
 		gn->add_child(hbc);
@@ -1692,11 +1902,21 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("DotProduct");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("dp")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1707,7 +1927,12 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("Vec2Scalar");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("vec")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("vec", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("vec: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("x"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -1732,12 +1957,27 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		gn->set_title("Scalar2Vec");
 		HBoxContainer *hbc = memnew( HBoxContainer );
-		hbc->add_child( memnew(Label("x")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("x", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("x: ")+Variant(v),gn,p_id,0,Variant::REAL));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("vec")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("y")));
-		gn->add_child( memnew(Label("z")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("y", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("y: ")+Variant(v),gn,p_id,1,Variant::REAL));
+		}
+		if (graph->is_slot_connected(type, p_id, 2)) {
+			gn->add_child(make_label("in", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,2);
+			gn->add_child(make_editor(String("in: ")+Variant(v),gn,p_id,2,Variant::REAL));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
@@ -1749,13 +1989,33 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("Vec2XForm");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("x")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("x", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("x: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("xf")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("y")));
-		gn->add_child( memnew(Label("z")));
-		gn->add_child( memnew(Label("ofs")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("y", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("y: ")+v,gn,p_id,1,Variant::VECTOR3));
+		}
+		if (graph->is_slot_connected(type, p_id, 2)) {
+			gn->add_child(make_label("z", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,2);
+			gn->add_child(make_editor(String("z: ")+v,gn,p_id,2,Variant::VECTOR3));
+		}
+		if (graph->is_slot_connected(type, p_id, 3)) {
+			gn->add_child(make_label("ofs", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,3);
+			gn->add_child(make_editor(String("ofs: ")+v,gn,p_id,3,Variant::VECTOR3));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1769,7 +2029,11 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("xf")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("fx", Variant::TRANSFORM));
+		} else {
+			hbc->add_child(make_editor(String("fx: edit..."),gn,p_id,0,Variant::TRANSFORM));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("x"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -1796,12 +2060,27 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("ScalarInterp");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("interp")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
-		gn->add_child( memnew(Label("c")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
+		}
+		if (graph->is_slot_connected(type, p_id, 2)) {
+			gn->add_child(make_label("c", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,2);
+			gn->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,2,Variant::REAL,hint_slider));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
@@ -1813,12 +2092,27 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		gn->set_title("VecInterp");
 		HBoxContainer *hbc = memnew( HBoxContainer );
-		hbc->add_child( memnew(Label("a")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("a", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		hbc->add_child( memnew(Label("interp")));
 		gn->add_child(hbc);
-		gn->add_child( memnew(Label("b")));
-		gn->add_child( memnew(Label("c")));
+		if (graph->is_slot_connected(type, p_id, 1)) {
+			gn->add_child(make_label("b", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,1);
+			gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
+		}
+		if (graph->is_slot_connected(type, p_id, 2)) {
+			gn->add_child(make_label("c", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,2);
+			gn->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,2,Variant::REAL,hint_slider));
+		}
 
 		gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
 		gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
@@ -1857,7 +2151,12 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("c")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("c", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_slider));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("rgb"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -1902,7 +2201,12 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("c")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("c", Variant::REAL));
+		} else {
+			float v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_slider));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("cmap"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -2016,7 +2320,12 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("UV")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("UV", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("RGB"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -2047,7 +2356,12 @@ void ShaderGraphView::_create_node(int p_id) {
 
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("UV")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("UV", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("RGB"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -2067,7 +2381,12 @@ void ShaderGraphView::_create_node(int p_id) {
 		gn->set_title("CanvasItemTex");
 		HBoxContainer *hbc = memnew( HBoxContainer );
 		hbc->add_constant_override("separation",0);
-		hbc->add_child( memnew(Label("UV")));
+		if (graph->is_slot_connected(type, p_id, 0)) {
+			hbc->add_child(make_label("UV", Variant::VECTOR3));
+		} else {
+			Vector3 v = graph->default_get_value(type,p_id,0);
+			hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
+		}
 		hbc->add_spacer();
 		Label *l=memnew(Label("RGB"));
 		l->set_align(Label::ALIGN_RIGHT);
@@ -2091,15 +2410,34 @@ void ShaderGraphView::_create_node(int p_id) {
 		List<ShaderGraph::SlotInfo> si;
 		ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
 
+		Array colors;
+		colors.push_back("Color");
+		colors.push_back("LightColor");
+		Array reals;
+		reals.push_back("Alpha");
+		reals.push_back("NormapMapDepth");
+		reals.push_back("LightAlpha");
+		reals.push_back("PointSize");
+		Array vectors;
+		vectors.push_back("Normal");
+		vectors.push_back("NormalMap");
+		vectors.push_back("Vertex");
+		vectors.push_back("UV");
+		vectors.push_back("Var1");
+		vectors.push_back("Var2");
+
 		int idx=0;
 		for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
 			ShaderGraph::SlotInfo& s=E->get();
 			if (s.dir==ShaderGraph::SLOT_OUT) {
-
-				Label *l= memnew( Label );
-				l->set_text(s.name);
-				l->set_align(Label::ALIGN_LEFT);
-				gn->add_child(l);
+				Variant::Type v;
+				if (colors.find(s.name)>=0)
+					v=Variant::COLOR;
+				else if (reals.find(s.name)>=0)
+					v=Variant::REAL;
+				else if (vectors.find(s.name)>=0)
+					v=Variant::VECTOR3;
+				gn->add_child(make_label(s.name, v));
 				gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
 				idx++;
 			}
@@ -2256,6 +2594,7 @@ void ShaderGraphView::_bind_methods() {
 	ObjectTypeDB::bind_method("_duplicate_nodes", &ShaderGraphView::_duplicate_nodes);
 	ObjectTypeDB::bind_method("_delete_nodes_request", &ShaderGraphView::_delete_nodes_request);
 
+	ObjectTypeDB::bind_method("_default_changed",&ShaderGraphView::_default_changed);
 	ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
 	ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
 	ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h
index 36443efeb0..800fdf1fea 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.h
+++ b/tools/editor/plugins/shader_graph_editor_plugin.h
@@ -129,6 +129,7 @@ class ShaderGraphView : public Node {
 	GraphEdit *graph_edit;
 	Ref<ShaderGraph> graph;
 	int edited_id;
+	int edited_def;
 
 	ShaderGraph::ShaderType type;
 
@@ -136,6 +137,8 @@ class ShaderGraphView : public Node {
 	void _create_node(int p_id);
 
 
+	ToolButton *make_label(String text, Variant::Type v_type = Variant::NIL);
+	ToolButton *make_editor(String text, GraphNode* gn, int p_id, int param, Variant::Type type, String p_hint="");
 
 	void _connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
 	void _disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot);
@@ -149,6 +152,9 @@ class ShaderGraphView : public Node {
 	void _duplicate_nodes(Array &p_nodes);
 	void _delete_nodes_request();
 
+
+	void _default_changed(int p_id, Node* p_button, int p_param, int v_type, String p_hint);
+
 	void _scalar_const_changed(double p_value,int p_id);
 	void _vec_const_changed(double p_value, int p_id, Array p_arr);
 	void _rgb_const_changed(const Color& p_color, int p_id);
diff --git a/tools/editor/property_editor.cpp b/tools/editor/property_editor.cpp
index 78a1f0ad15..ae0975c896 100644
--- a/tools/editor/property_editor.cpp
+++ b/tools/editor/property_editor.cpp
@@ -42,15 +42,15 @@
 #include "multi_node_edit.h"
 
 void CustomPropertyEditor::_notification(int p_what) {
-	
+
 
 	if (p_what==NOTIFICATION_DRAW) {
-		
+
 		RID ci = get_canvas_item();
-		get_stylebox("panel","PopupMenu")->draw(ci,Rect2(Point2(),get_size()));		
+		get_stylebox("panel","PopupMenu")->draw(ci,Rect2(Point2(),get_size()));
 		/*
 		if (v.get_type()==Variant::COLOR) {
-			
+
 			VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2( 10,10,60, get_size().height-20 ), v );
 		}*/
 	}
@@ -211,11 +211,11 @@ void CustomPropertyEditor::_menu_option(int p_which) {
 }
 
 Variant CustomPropertyEditor::get_variant() const {
-	
-	return v;	
+
+	return v;
 }
 String CustomPropertyEditor::get_name() const {
-	
+
 	return name;
 }
 
@@ -233,9 +233,11 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 	inheritors_array.clear();
 	text_edit->hide();
 	easing_draw->hide();
-	
+	spinbox->hide();
+	slider->hide();
+
 	for (int i=0;i<MAX_VALUE_EDITORS;i++) {
-		
+
 		value_editor[i]->hide();
 		value_label[i]->hide();
 		if (i<4)
@@ -243,8 +245,8 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 	}
 
 	for (int i=0;i<MAX_ACTION_BUTTONS;i++) {
-	
-		action_buttons[i]->hide();	
+
+		action_buttons[i]->hide();
 	}
 
 	for(int i=0;i<20;i++)
@@ -254,11 +256,49 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 
 
 	switch(type) {
-	
+
 		case Variant::INT:
 		case Variant::REAL: {
 
-			if (hint==PROPERTY_HINT_ALL_FLAGS) {
+			if (hint==PROPERTY_HINT_RANGE) {
+
+				int c = hint_text.get_slice_count(",");
+				float min=0,max=100,step=1;
+				if (c>=1) {
+
+					if (!hint_text.get_slice(",",0).empty())
+						min=hint_text.get_slice(",",0).to_double();
+				}
+				if (c>=2) {
+
+					if (!hint_text.get_slice(",",1).empty())
+					max=hint_text.get_slice(",",1).to_double();
+				}
+
+				if (type==Variant::REAL && c>=3) {
+
+					if (!hint_text.get_slice(",",2).empty())
+					step= hint_text.get_slice(",",2).to_double();
+				}
+
+				if (c>=4 && hint_text.get_slice(",",3)=="slider") {
+					slider->set_min(min);
+					slider->set_max(max);
+					slider->set_step((type==Variant::REAL) ? step : 1);
+					slider->set_val(v);
+					slider->show();
+					set_size(Size2(110,30));
+				} else {
+					spinbox->set_min(min);
+					spinbox->set_max(max);
+					spinbox->set_step((type==Variant::REAL) ? step : 1);
+					spinbox->set_val(v);
+					spinbox->show();
+					set_size(Size2(70,35));
+				}
+
+
+			} else if (hint==PROPERTY_HINT_ALL_FLAGS) {
 
 				uint32_t flgs = v;
 				for(int i=0;i<2;i++) {
@@ -406,7 +446,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			value_editor[3]->set_text( String::num( r.size.y) );
 		} break;
 		case Variant::VECTOR3: {
-			
+
 			List<String> names;
 			names.push_back("x");
 			names.push_back("y");
@@ -418,7 +458,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			value_editor[2]->set_text( String::num( vec.z) );
 		} break;
 		case Variant::PLANE: {
-			
+
 			List<String> names;
 			names.push_back("x");
 			names.push_back("y");
@@ -430,10 +470,10 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			value_editor[1]->set_text( String::num( plane.normal.y ) );
 			value_editor[2]->set_text( String::num( plane.normal.z ) );
 			value_editor[3]->set_text( String::num( plane.d ) );
-			
+
 		} break;
 		case Variant::QUAT: {
-			
+
 			List<String> names;
 			names.push_back("x");
 			names.push_back("y");
@@ -448,7 +488,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 
 		} break;
 		case Variant::_AABB: {
-			
+
 			List<String> names;
 			names.push_back("px");
 			names.push_back("py");
@@ -457,7 +497,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			names.push_back("sy");
 			names.push_back("sz");
 			config_value_editors(6,3,16,names);
-			
+
 			AABB aabb=v;
 			value_editor[0]->set_text( String::num( aabb.pos.x ) );
 			value_editor[1]->set_text( String::num( aabb.pos.y ) );
@@ -465,7 +505,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			value_editor[3]->set_text( String::num( aabb.size.x ) );
 			value_editor[4]->set_text( String::num( aabb.size.y ) );
 			value_editor[5]->set_text( String::num( aabb.size.z ) );
-			
+
 		} break;
 		case Variant::MATRIX32: {
 
@@ -486,7 +526,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 
 		} break;
 		case Variant::MATRIX3: {
-			
+
 			List<String> names;
 			names.push_back("xx");
 			names.push_back("xy");
@@ -498,17 +538,17 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			names.push_back("zy");
 			names.push_back("zz");
 			config_value_editors(9,3,16,names);
-			
+
 			Matrix3 basis=v;
 			for(int i=0;i<9;i++) {
-				
+
 				value_editor[i]->set_text( String::num( basis.elements[i/3][i%3] ) );
 			}
-			
+
 		} break;
 		case Variant::TRANSFORM: {
-			
-			
+
+
 			List<String> names;
 			names.push_back("xx");
 			names.push_back("xy");
@@ -523,20 +563,20 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			names.push_back("zz");
 			names.push_back("zo");
 			config_value_editors(12,4,16,names);
-			
+
 			Transform tr=v;
 			for(int i=0;i<9;i++) {
-				
+
 				value_editor[(i/3)*4+i%3]->set_text( String::num( tr.basis.elements[i/3][i%3] ) );
 			}
-			
+
 			value_editor[3]->set_text( String::num( tr.origin.x ) );
 			value_editor[7]->set_text( String::num( tr.origin.y ) );
 			value_editor[11]->set_text( String::num( tr.origin.z ) );
-			
+
 		} break;
 		case Variant::COLOR: {
-			
+
 
 			color_picker->show();
 			color_picker->set_edit_alpha(hint!=PROPERTY_HINT_COLOR_NO_ALPHA);
@@ -550,13 +590,13 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 			float values[4]={c.r,c.g,c.b,c.a};
 			for (int i=0;i<4;i++) {
 				int y=m+i*h;
-				
+
 				value_editor[i]->show();
-				value_label[i]->show();				
+				value_label[i]->show();
 				value_label[i]->set_pos(Point2(ofs,y));
 				scroll[i]->set_min(0);
 				scroll[i]->set_max(1.0);
-				scroll[i]->set_page(0);		
+				scroll[i]->set_page(0);
 				scroll[i]->set_pos(Point2(ofs+15,y+Math::floor((h-scroll[i]->get_minimum_size().height)/2.0)));
 				scroll[i]->set_val(values[i]);
 				scroll[i]->set_size(Size2(120,1));
@@ -564,30 +604,30 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 				value_editor[i]->set_pos(Point2(ofs+140,y));
 				value_editor[i]->set_size(Size2(40,h));
 				value_editor[i]->set_text( String::num(values[i],2 ));
-				
+
 			}
-			
+
 			value_label[0]->set_text("R");
 			value_label[1]->set_text("G");
 			value_label[2]->set_text("B");
 			value_label[3]->set_text("A");
-			
+
 			Size2 new_size = value_editor[3]->get_pos() + value_editor[3]->get_size() + Point2(10,10);
 			set_size( new_size );
 			*/
-			
+
 		} break;
 		case Variant::IMAGE: {
-			
+
 			List<String> names;
 			names.push_back("New");
 			names.push_back("Load");
 			names.push_back("Clear");
 			config_action_buttons(names);
-			
+
 		} break;
 		case Variant::NODE_PATH: {
-			
+
 			List<String> names;
 			names.push_back("Assign");
 			names.push_back("Clear");
@@ -595,7 +635,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 
 		} break;
 		case Variant::OBJECT: {
-			
+
 			if (hint!=PROPERTY_HINT_RESOURCE_TYPE)
 				break;
 
@@ -701,40 +741,40 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 
 		} break;
 		case Variant::INPUT_EVENT: {
-			
-			
+
+
 		} break;
 		case Variant::DICTIONARY: {
-			
-			
+
+
 		} break;
 		case Variant::RAW_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::INT_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::REAL_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::STRING_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::VECTOR3_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::COLOR_ARRAY: {
-			
-			
+
+
 		} break;
 		default: {}
-	}		
-	
+	}
+
 	updating=false;
 	return true;
 }
@@ -742,7 +782,7 @@ bool CustomPropertyEditor::edit(Object* p_owner,const String& p_name,Variant::Ty
 void CustomPropertyEditor::_file_selected(String p_file) {
 
 	switch(type) {
-		
+
 		case Variant::STRING: {
 
 			if (hint==PROPERTY_HINT_FILE || hint==PROPERTY_HINT_DIR) {
@@ -880,9 +920,9 @@ void CustomPropertyEditor::_node_path_selected(NodePath p_path) {
 void CustomPropertyEditor::_action_pressed(int p_which) {
 
 
-	if (updating) 
+	if (updating)
 		return;
-	
+
 	switch(type) {
 		case Variant::INT: {
 
@@ -965,7 +1005,7 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 
 		} break;
 		case Variant::NODE_PATH: {
-				
+
 			if (p_which==0) {
 
 
@@ -976,60 +1016,60 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 
 				v=NodePath();
 				emit_signal("variant_changed");
-			}				
+			}
 		} break;
 		case Variant::OBJECT: {
-		
+
 			if (p_which==0) {
-			
+
 
 				ERR_FAIL_COND( inheritors_array.empty() );
 
 				String intype=inheritors_array[0];
 
-				
+
 				if (hint==PROPERTY_HINT_RESOURCE_TYPE) {
-				
+
 					Object *obj = ObjectTypeDB::instance(intype);
 					ERR_BREAK( !obj );
 					Resource *res=obj->cast_to<Resource>();
 					ERR_BREAK( !res );
-					
+
 					v=Ref<Resource>(res).get_ref_ptr();
 					emit_signal("variant_changed");
 					hide();
-						
+
 				}
 			} else if (p_which==1) {
-			
+
 				file->set_access(EditorFileDialog::ACCESS_RESOURCES);
 				file->set_mode(EditorFileDialog::MODE_OPEN_FILE);
 				List<String> extensions;
 				String type=(hint==PROPERTY_HINT_RESOURCE_TYPE)?hint_text:String();
-				
+
 				ResourceLoader::get_recognized_extensions_for_type(type,&extensions);
 				file->clear_filters();
 				for (List<String>::Element *E=extensions.front();E;E=E->next()) {
-				
+
 					file->add_filter("*."+E->get()+" ; "+E->get().to_upper() );
-				
+
 				}
-				
+
 				file->popup_centered_ratio();
-			
+
 			} else if (p_which==2) {
-			
+
 				RefPtr RefPtr=v;
 
 				if (!RefPtr.is_null()) {
 
 					emit_signal("resource_edit_request");
-					hide();	
+					hide();
 				}
-			
+
 			} else if (p_which==3) {
-			
-			
+
+
 				v=Variant();
 				emit_signal("variant_changed");
 				hide();
@@ -1072,7 +1112,7 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 				emit_signal("variant_changed");
 				hide();
 			}
-				
+
 		} break;
 		case Variant::IMAGE: {
 
@@ -1111,16 +1151,16 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 }
 
 void CustomPropertyEditor::_scroll_modified(double p_value) {
-	
-	if (updating) 
+
+	if (updating)
 		return;
 	/*
 	switch(type) {
-		
+
 		case Variant::COLOR: {
-			
+
 			for (int i=0;i<4;i++) {
-				
+
 				value_editor[i]->set_text( String::num(scroll[i]->get_val(),2) );
 			}
 			Color c;
@@ -1145,7 +1185,7 @@ void CustomPropertyEditor::_drag_easing(const InputEvent& p_ev) {
 
 		float rel = p_ev.mouse_motion.relative_x;
 		if (rel==0)
-		    return;
+			return;
 
 		bool flip=hint_text=="attenuation";
 
@@ -1228,7 +1268,7 @@ void CustomPropertyEditor::_text_edit_changed() {
 }
 
 void CustomPropertyEditor::_modified(String p_string) {
-	
+
 	if (updating)
 		return;
 	updating=true;
@@ -1269,17 +1309,17 @@ void CustomPropertyEditor::_modified(String p_string) {
 		} break;
 
 		case Variant::VECTOR3: {
-			
+
 			Vector3 vec;
 			vec.x=value_editor[0]->get_text().to_double();
 			vec.y=value_editor[1]->get_text().to_double();
 			vec.z=value_editor[2]->get_text().to_double();
 			v=vec;
 			emit_signal("variant_changed");
-			
+
 		} break;
 		case Variant::PLANE: {
-			
+
 			Plane pl;
 			pl.normal.x=value_editor[0]->get_text().to_double();
 			pl.normal.y=value_editor[1]->get_text().to_double();
@@ -1287,10 +1327,10 @@ void CustomPropertyEditor::_modified(String p_string) {
 			pl.d=value_editor[3]->get_text().to_double();
 			v=pl;
 			emit_signal("variant_changed");
-			
+
 		} break;
 		case Variant::QUAT: {
-			
+
 			Quat q;
 			q.x=value_editor[0]->get_text().to_double();
 			q.y=value_editor[1]->get_text().to_double();
@@ -1298,10 +1338,10 @@ void CustomPropertyEditor::_modified(String p_string) {
 			q.w=value_editor[3]->get_text().to_double();
 			v=q;
 			emit_signal("variant_changed");
-			
+
 		} break;
 		case Variant::_AABB: {
-			
+
 			Vector3 pos;
 			pos.x=value_editor[0]->get_text().to_double();
 			pos.y=value_editor[1]->get_text().to_double();
@@ -1310,10 +1350,10 @@ void CustomPropertyEditor::_modified(String p_string) {
 			size.x=value_editor[3]->get_text().to_double();
 			size.y=value_editor[4]->get_text().to_double();
 			size.z=value_editor[5]->get_text().to_double();
-			
+
 			v=AABB(pos,size);
 			emit_signal("variant_changed");
-			
+
 		} break;
 		case Variant::MATRIX32: {
 
@@ -1328,39 +1368,39 @@ void CustomPropertyEditor::_modified(String p_string) {
 
 		} break;
 		case Variant::MATRIX3: {
-			
+
 			Matrix3 m;
 			for(int i=0;i<9;i++) {
-					
+
 				m.elements[i/3][i%3]=value_editor[i]->get_text().to_double();
 			}
-			
+
 			v=m;
 			emit_signal("variant_changed");
-			
+
 		} break;
 		case Variant::TRANSFORM: {
-			
+
 			Matrix3 basis;
 			for(int i=0;i<9;i++) {
-				
+
 				basis.elements[i/3][i%3]=value_editor[(i/3)*4+i%3]->get_text().to_double();
 			}
-			
+
 			Vector3 origin;
 			origin.x=value_editor[3]->get_text().to_double();
 			origin.y=value_editor[7]->get_text().to_double();
 			origin.z=value_editor[11]->get_text().to_double();
-			
+
 			v=Transform(basis,origin);
 			emit_signal("variant_changed");
-			
-			
+
+
 		} break;
 		case Variant::COLOR: {
 			/*
 			for (int i=0;i<4;i++) {
-				
+
 				scroll[i]->set_val( value_editor[i]->get_text().to_double() );
 			}
 			Color c;
@@ -1374,51 +1414,57 @@ void CustomPropertyEditor::_modified(String p_string) {
 			*/
 		} break;
 		case Variant::IMAGE: {
-			
-			
+
+
 		} break;
 		case Variant::NODE_PATH: {
-			
-			
-		} break;		
+
+
+		} break;
 		case Variant::INPUT_EVENT: {
-			
-			
+
+
 		} break;
 		case Variant::DICTIONARY: {
-			
-			
+
+
 		} break;
 		case Variant::RAW_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::INT_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::REAL_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::STRING_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::VECTOR3_ARRAY: {
-			
-			
+
+
 		} break;
 		case Variant::COLOR_ARRAY: {
-			
-			
+
+
 		} break;
 		default: {}
-	}		
-	
+	}
+
 	updating=false;
 }
 
+void CustomPropertyEditor::_range_modified(double p_value)
+{
+	v=p_value;
+	emit_signal("variant_changed");
+}
+
 void CustomPropertyEditor::_focus_enter() {
 	switch(type) {
 		case Variant::REAL:
@@ -1475,10 +1521,10 @@ void CustomPropertyEditor::config_action_buttons(const List<String>& p_strings)
 	set_size( Size2( w, m*2+(h+m)*p_strings.size() ) );
 
 	for (int i=0;i<MAX_ACTION_BUTTONS;i++) {
-				
+
 		if (i<p_strings.size()) {
 			action_buttons[i]->show();
-			action_buttons[i]->set_text(p_strings[i]);			
+			action_buttons[i]->set_text(p_strings[i]);
 			action_buttons[i]->set_pos( Point2( m, m+i*(h+m) ));
 			action_buttons[i]->set_size( Size2( w-m*2, h ) );
 			action_buttons[i]->set_flat(true);
@@ -1486,29 +1532,29 @@ void CustomPropertyEditor::config_action_buttons(const List<String>& p_strings)
 			action_buttons[i]->hide();
 		}
 	}
-	
-	
+
+
 }
 
 void CustomPropertyEditor::config_value_editors(int p_amount, int p_columns,int p_label_w,const List<String>& p_strings) {
-	
+
 	int w=80;
 	int h=20;
 	int m=10;
-	
+
 	int rows=((p_amount-1)/p_columns)+1;
-	
+
 	set_size( Size2( m*(1+p_columns)+(w+p_label_w)*p_columns, m*(1+rows)+h*rows ) );
-		
+
 	for (int i=0;i<MAX_VALUE_EDITORS;i++) {
-		
+
 		int c=i%p_columns;
 		int r=i/p_columns;
-		
+
 		if (i<p_amount) {
 			value_editor[i]->show();
 			value_label[i]->show();
-			value_label[i]->set_text(i<p_strings.size()?p_strings[i]:String(""));			
+			value_label[i]->set_text(i<p_strings.size()?p_strings[i]:String(""));
 			value_editor[i]->set_pos( Point2( m+p_label_w+c*(w+m+p_label_w), m+r*(h+m) ));
 			value_editor[i]->set_size( Size2( w, h ) );
 			value_label[i]->set_pos( Point2( m+c*(w+m+p_label_w), m+r*(h+m) ) );
@@ -1518,16 +1564,17 @@ void CustomPropertyEditor::config_value_editors(int p_amount, int p_columns,int
 			value_label[i]->hide();
 		}
 	}
-	
-	
-	
+
+
+
 }
 
 void CustomPropertyEditor::_bind_methods() {
-	
+
 	ObjectTypeDB::bind_method("_focus_enter", &CustomPropertyEditor::_focus_enter);
 	ObjectTypeDB::bind_method("_focus_exit", &CustomPropertyEditor::_focus_exit);
 	ObjectTypeDB::bind_method("_modified",&CustomPropertyEditor::_modified);
+	ObjectTypeDB::bind_method("_range_modified", &CustomPropertyEditor::_range_modified);
 	ObjectTypeDB::bind_method("_scroll_modified",&CustomPropertyEditor::_scroll_modified);
 	ObjectTypeDB::bind_method("_action_pressed",&CustomPropertyEditor::_action_pressed);
 	ObjectTypeDB::bind_method("_file_selected",&CustomPropertyEditor::_file_selected);
@@ -1544,13 +1591,13 @@ void CustomPropertyEditor::_bind_methods() {
 	ADD_SIGNAL( MethodInfo("resource_edit_request") );
 }
 CustomPropertyEditor::CustomPropertyEditor() {
-	
-	
+
+
 	read_only=false;
 	updating=false;
-	
+
 	for (int i=0;i<MAX_VALUE_EDITORS;i++) {
-		
+
 		value_editor[i]=memnew( LineEdit );
 		add_child( value_editor[i] );
 		value_label[i]=memnew( Label );
@@ -1561,17 +1608,17 @@ CustomPropertyEditor::CustomPropertyEditor() {
 		value_editor[i]->connect("focus_enter", this, "_focus_enter");
 		value_editor[i]->connect("focus_exit", this, "_focus_exit");
 	}
-	
+
 	for(int i=0;i<4;i++) {
-	
+
 		scroll[i] = memnew( HScrollBar );
 		scroll[i]->hide();
 		scroll[i]->set_min(0);
 		scroll[i]->set_max(1.0);
-		scroll[i]->set_step(0.01);		
+		scroll[i]->set_step(0.01);
 		add_child(scroll[i]);
 		scroll[i]->connect("value_changed", this,"_scroll_modified");
-		
+
 	}
 
 	for(int i=0;i<20;i++) {
@@ -1595,15 +1642,15 @@ CustomPropertyEditor::CustomPropertyEditor() {
 	text_edit->connect("text_changed",this,"_text_edit_changed");
 
 	for (int i=0;i<MAX_ACTION_BUTTONS;i++) {
-	
+
 		action_buttons[i]=memnew(Button);
-		action_buttons[i]->hide();	
+		action_buttons[i]->hide();
 		add_child(action_buttons[i]);
 		Vector<Variant> binds;
 		binds.push_back(i);
 		action_buttons[i]->connect("pressed", this,"_action_pressed",binds);
 	}
-	
+
 	color_picker = memnew( ColorPicker );
 	add_child(color_picker);
 	color_picker->hide();
@@ -1616,7 +1663,7 @@ CustomPropertyEditor::CustomPropertyEditor() {
 	file = memnew ( EditorFileDialog );
 	add_child(file);
 	file->hide();
-	
+
 	file->connect("file_selected", this,"_file_selected");
 	file->connect("dir_selected", this,"_file_selected");
 
@@ -1624,12 +1671,12 @@ CustomPropertyEditor::CustomPropertyEditor() {
 	error->set_title("Error!");
 	add_child(error);
 	//error->get_cancel()->hide();
-	
+
 	type_button = memnew( MenuButton );
 	add_child(type_button);
 	type_button->hide();
 	type_button->get_popup()->connect("item_pressed", this,"_type_create_selected");
-	
+
 
 	scene_tree = memnew( SceneTreeDialog );
 	add_child(scene_tree);
@@ -1651,6 +1698,16 @@ CustomPropertyEditor::CustomPropertyEditor() {
 	menu = memnew(PopupMenu);
 	add_child(menu);
 	menu->connect("item_pressed",this,"_menu_option");
+
+	spinbox = memnew ( SpinBox );
+	add_child(spinbox);
+	spinbox->set_area_as_parent_rect(5);
+	spinbox->connect("value_changed",this,"_range_modified");
+
+	slider = memnew ( HSlider );
+	add_child(slider);
+	slider->set_area_as_parent_rect(5);
+	slider->connect("value_changed",this,"_range_modified");
 }
 
 
@@ -1675,28 +1732,28 @@ Node *PropertyEditor::get_instanced_node() {
 }
 
 TreeItem *PropertyEditor::find_item(TreeItem *p_item,const String& p_name) {
-	
-	
+
+
 	if (!p_item)
 		return NULL;
-	
+
 	String name = p_item->get_metadata(1);
-	
+
 	if (name==p_name) {
-		
+
 		return p_item;
 	}
-	
+
 	TreeItem *c=p_item->get_children();
-	
+
 	while (c) {
-		
+
 		TreeItem *found = find_item(c,p_name);
 		if (found)
 			return found;
 		c=c->get_next();
 	}
-	
+
 	return NULL;
 }
 
@@ -1719,9 +1776,9 @@ void PropertyEditor::_changed_callbacks(Object *p_changed,const String& p_prop)
 	if (p_prop==String())
 		update_tree_pending=true;
 	else {
-		
+
 		pending[p_prop]=p_prop;
-			
+
 	}
 }
 
@@ -1733,7 +1790,7 @@ void PropertyEditor::update_property(const String& p_prop) {
 
 
 void PropertyEditor::set_item_text(TreeItem *p_item, int p_type, const String& p_name, int p_hint, const String& p_hint_text) {
-	
+
 	switch( p_type ) {
 
 		case Variant::BOOL: {
@@ -1826,7 +1883,7 @@ void PropertyEditor::set_item_text(TreeItem *p_item, int p_type, const String& p
 
 		} break;
 		case Variant::IMAGE: {
-		
+
 			Image img = obj->get( p_name );
 			if (img.empty())
 				p_item->set_text(1,"[Image (empty)]");
@@ -1905,7 +1962,7 @@ void PropertyEditor::set_item_text(TreeItem *p_item, int p_type, const String& p
 		} break;
 		default: {};
 	}
-	
+
 }
 
 void PropertyEditor::_notification(int p_what) {
@@ -1920,10 +1977,10 @@ void PropertyEditor::_notification(int p_what) {
 		edit(NULL);
 	}
 
-	
+
 	if (p_what==NOTIFICATION_FIXED_PROCESS) {
-		
-		
+
+
 		if (refresh_countdown>0) {
 			refresh_countdown-=get_fixed_process_delta_time();
 			if (refresh_countdown<=0) {
@@ -1933,21 +1990,21 @@ void PropertyEditor::_notification(int p_what) {
 		}
 
 		changing=true;
-		 
+
 		if (update_tree_pending) {
 
 			update_tree();
 			update_tree_pending=false;
-			
+
 		} else {
-			
-			const String *k=NULL;	
+
+			const String *k=NULL;
 			while ((k=pending.next(k))) {
-				
+
 				TreeItem * item = find_item(tree->get_root(),*k);
 				if (!item)
 					continue;
-				
+
 				if (get_instanced_node()) {
 
 					Dictionary d = get_instanced_node()->get_instance_state();
@@ -1981,15 +2038,15 @@ void PropertyEditor::_notification(int p_what) {
 					}
 
 				}
-				Dictionary d=item->get_metadata(0);	
+				Dictionary d=item->get_metadata(0);
 				set_item_text(item,d["type"],d["name"],d["hint"],d["hint_text"]);
-			}				
+			}
 		}
-			
+
 		pending.clear();
-			
+
 		changing=false;
-			
+
 	}
 }
 
@@ -2271,20 +2328,20 @@ void PropertyEditor::update_tree() {
 		d["type"]=(int)p.type;
 		d["hint"]=(int)p.hint;
 		d["hint_text"]=p.hint_string;
-					
+
 		item->set_metadata( 0, d );
 		item->set_metadata( 1, p.name );
 
 		if (draw_red)
 			item->set_custom_color(0,Color(0.8,0.4,0.20));
 
-		
+
 		if (p.name==selected_property) {
 
 			item->select(1);
 		}
 
-		
+
 		//printf("property %s type %i\n",p.name.ascii().get_data(),p.type);
 		switch( p.type ) {
 
@@ -2365,8 +2422,8 @@ void PropertyEditor::update_tree() {
 					if (p.type==Variant::REAL && c>=3) {
 
 						step= p.hint_string.get_slice(",",2).to_double();
-					} 
-					
+					}
+
 
 					item->set_range_config(1,min,max,step,p.hint==PROPERTY_HINT_EXP_RANGE);
 				} else if (p.hint==PROPERTY_HINT_ENUM) {
@@ -2549,7 +2606,7 @@ void PropertyEditor::update_tree() {
 
 			} break;
 			case Variant::IMAGE: {
-			
+
 				item->set_cell_mode( 1, TreeItem::CELL_MODE_CUSTOM );
 				item->set_editable( 1, !read_only );
 				Image img = obj->get( p.name );
@@ -2558,7 +2615,7 @@ void PropertyEditor::update_tree() {
 				else
 					item->set_text(1,"[Image "+itos(img.get_width())+"x"+itos(img.get_height())+"]");
 				item->set_icon( 0,get_icon("Image","EditorIcons") );
-			
+
 			} break;
 			case Variant::NODE_PATH: {
 
@@ -2709,10 +2766,10 @@ void PropertyEditor::_edit_set(const String& p_name, const Variant& p_value) {
 
 void PropertyEditor::_item_edited() {
 
-	
-	TreeItem * item = tree->get_edited();		
+
+	TreeItem * item = tree->get_edited();
 	Dictionary d = item->get_metadata(0);
-	
+
 	String name=d["name"];
 
 	if (tree->get_edited_column()==0) {
@@ -2741,12 +2798,12 @@ void PropertyEditor::_item_edited() {
 	int hint= d["hint"];
 	String hint_text=d["hint_text"];
 	switch(type) {
-		
+
 		case Variant::NIL: {
-			
-		} break;			
+
+		} break;
 		case Variant::BOOL: {
-			
+
 			_edit_set(name,item->is_checked(1));
 		} break;
 		case Variant::INT:
@@ -2765,7 +2822,7 @@ void PropertyEditor::_item_edited() {
 				_edit_set(name,item->get_range(1));
 		} break;
 		case Variant::STRING: {
-			
+
 			if (hint==PROPERTY_HINT_ENUM) {
 
 				int idx= item->get_range(1);
@@ -2783,64 +2840,64 @@ void PropertyEditor::_item_edited() {
 			}
 		} break;
 			// math types
-			
+
 		case Variant::VECTOR3: {
-			
+
 		} break;
 		case Variant::PLANE: {
-			
+
 		} break;
 		case Variant::QUAT: {
-			
+
 		} break;
 		case Variant::_AABB: {
-			
+
 		} break;
 		case Variant::MATRIX3: {
-			
+
 		} break;
 		case Variant::TRANSFORM: {
-			
+
 		} break;
-			
+
 		case Variant::COLOR: {
 			//_edit_set(name,item->get_custom_bg_color(0));
 		} break;
 		case Variant::IMAGE: {
-			
+
 		} break;
 		case Variant::NODE_PATH: {
-			
+
 		} break;
 
 		case Variant::INPUT_EVENT: {
-			
+
 		} break;
 		case Variant::DICTIONARY: {
-			
+
 		} break;
-			
+
 			// arrays
 		case Variant::RAW_ARRAY: {
-			
+
 		} break;
 		case Variant::INT_ARRAY: {
-			
+
 		} break;
 		case Variant::REAL_ARRAY: {
-			
+
 		} break;
 		case Variant::STRING_ARRAY: {
-			
+
 		} break;
 		case Variant::VECTOR3_ARRAY: {
-			
+
 		} break;
 		case Variant::COLOR_ARRAY: {
-			
+
 		} break;
-			
-		
+
+
 	};
 }
 
@@ -2891,24 +2948,24 @@ void PropertyEditor::_custom_editor_request(bool p_arrow) {
 }
 
 void PropertyEditor::edit(Object* p_object) {
-	
+
 
 	if (obj==p_object)
 		return;
 	if (obj) {
-		
+
 		obj->remove_change_receptor(this);
 	}
 
 	obj=p_object;
 	update_tree();
-	
+
 	if (obj) {
-		
+
 		obj->add_change_receptor(this);
 	}
-	
-	
+
+
 }
 
 void PropertyEditor::_set_range_def(Object *p_item, String prop,float p_frame) {
@@ -3003,9 +3060,9 @@ void PropertyEditor::_edit_button(Object *p_item, int p_column, int p_button) {
 
 
 void PropertyEditor::_node_removed(Node *p_node) {
-	
+
 	if (p_node==obj) {
-		
+
 		edit(NULL);
 	}
 }
@@ -3065,9 +3122,9 @@ void PropertyEditor::_bind_methods() {
 	ObjectTypeDB::bind_method( "_item_edited",&PropertyEditor::_item_edited);
 	ObjectTypeDB::bind_method( "_item_selected",&PropertyEditor::_item_selected);
 	ObjectTypeDB::bind_method( "_custom_editor_request",&PropertyEditor::_custom_editor_request);
-	ObjectTypeDB::bind_method( "_custom_editor_edited",&PropertyEditor::_custom_editor_edited);	
-	ObjectTypeDB::bind_method( "_resource_edit_request",&PropertyEditor::_resource_edit_request);	
-	ObjectTypeDB::bind_method( "_node_removed",&PropertyEditor::_node_removed);		
+	ObjectTypeDB::bind_method( "_custom_editor_edited",&PropertyEditor::_custom_editor_edited);
+	ObjectTypeDB::bind_method( "_resource_edit_request",&PropertyEditor::_resource_edit_request);
+	ObjectTypeDB::bind_method( "_node_removed",&PropertyEditor::_node_removed);
 	ObjectTypeDB::bind_method( "_edit_button",&PropertyEditor::_edit_button);
 	ObjectTypeDB::bind_method( "_changed_callback",&PropertyEditor::_changed_callbacks);
 	ObjectTypeDB::bind_method( "_draw_flags",&PropertyEditor::_draw_flags);
@@ -3127,29 +3184,29 @@ void PropertyEditor::set_show_categories(bool p_show) {
 }
 
 PropertyEditor::PropertyEditor() {
-	
+
 	_prop_edited="property_edited";
 	_prop_edited_name.push_back(String());
 	undo_redo=NULL;
 	obj=NULL;
 	changing=false;
 	update_tree_pending=false;
-	
+
 	top_label = memnew( Label );
 	top_label->set_text("Properties:");
 	top_label->set_anchor( MARGIN_RIGHT, ANCHOR_END );
 	top_label->set_begin( Point2( 10,0) );
-	top_label->set_end( Point2( 0,12) );		
-	
-	add_child(top_label);	
+	top_label->set_end( Point2( 0,12) );
+
+	add_child(top_label);
+
 
-	
 	tree = memnew( Tree );
 	tree->set_anchor( MARGIN_RIGHT, ANCHOR_END );
-	tree->set_anchor( MARGIN_BOTTOM, ANCHOR_END );	
+	tree->set_anchor( MARGIN_BOTTOM, ANCHOR_END );
 	tree->set_begin( Point2(0,19 ));
 	tree->set_end( Point2(0,0 ));
-	
+
 	tree->set_columns(2);
 	tree->set_column_expand(0,true);
 	tree->set_column_min_width(0,30);
@@ -3157,21 +3214,21 @@ PropertyEditor::PropertyEditor() {
 	tree->set_column_min_width(1,18);
 
 	//tree->set_hide_root(true);
-	add_child( tree );	
-	
+	add_child( tree );
+
 	tree->connect("item_edited", this,"_item_edited",varray(),CONNECT_DEFERRED);
 	tree->connect("cell_selected", this,"_item_selected");
-	
+
 	set_fixed_process(true);
-	
+
 	custom_editor = memnew( CustomPropertyEditor );
 	add_child(custom_editor);
-	
+
 	tree->connect("custom_popup_edited", this,"_custom_editor_request");
 	tree->connect("button_pressed", this,"_edit_button");
 	custom_editor->connect("variant_changed", this,"_custom_editor_edited");
 	custom_editor->connect("resource_edit_request", this,"_resource_edit_request",make_binds(),CONNECT_DEFERRED);
-	
+
 	capitalize_paths=true;
 	autoclear=false;
 	tree->set_column_title(0,"Property");
@@ -3182,7 +3239,7 @@ PropertyEditor::PropertyEditor() {
 	read_only=false;
 	show_categories=false;
 	refresh_countdown=0;
-	
+
 }
 
 
diff --git a/tools/editor/property_editor.h b/tools/editor/property_editor.h
index de5cac8711..f6e2dfcf50 100644
--- a/tools/editor/property_editor.h
+++ b/tools/editor/property_editor.h
@@ -46,9 +46,9 @@
 */
 
 class CustomPropertyEditor : public Popup {
-	
+
 	OBJ_TYPE( CustomPropertyEditor, Popup );
-	
+
 	enum {
 		MAX_VALUE_EDITORS=12,
 		MAX_ACTION_BUTTONS=5,
@@ -93,7 +93,8 @@ class CustomPropertyEditor : public Popup {
 	TextEdit *text_edit;
 	bool read_only;
 	Button *checks20[20];
-
+	SpinBox *spinbox;
+	HSlider *slider;
 
 	Control *easing_draw;
 
@@ -105,6 +106,7 @@ class CustomPropertyEditor : public Popup {
 	void _file_selected(String p_file);
 	void _scroll_modified(double p_value);
 	void _modified(String p_string);
+	void _range_modified(double p_value);
 	void _focus_enter();
 	void _focus_exit();
 	void _action_pressed(int p_which);
@@ -113,7 +115,7 @@ class CustomPropertyEditor : public Popup {
 	void _color_changed(const Color& p_color);
 	void _draw_easing();
 	void _menu_option(int p_which);
-	
+
 	void _drag_easing(const InputEvent& p_ev);
 
 	void _node_path_selected(NodePath p_path);
@@ -123,23 +125,23 @@ class CustomPropertyEditor : public Popup {
 protected:
 
 	void _notification(int p_what);
-	static void _bind_methods();			
-	
-public:	
+	static void _bind_methods();
+
+public:
 	Variant get_variant() const;
 	String get_name() const;
-	
+
 	void set_read_only(bool p_read_only) { read_only=p_read_only; }
 
 	bool edit(Object* p_owner,const String& p_name,Variant::Type p_type, const Variant& p_variant,int p_hint,String p_hint_text);
-	
+
 	CustomPropertyEditor();
 };
 
 class PropertyEditor : public Control {
-	
+
 	OBJ_TYPE( PropertyEditor, Control );
-	
+
 	Tree *tree;
 	Label *top_label;
 	//Object *object;
@@ -160,27 +162,27 @@ class PropertyEditor : public Control {
 
 	HashMap<String,String> pending;
 	String selected_property;
-	
+
 	CustomPropertyEditor *custom_editor;
-	
+
 	void _resource_edit_request();
 	void _custom_editor_edited();
 	void _custom_editor_request(bool p_arrow);
-	
+
 	void _item_selected();
 	void _item_edited();
 	TreeItem *get_parent_node(String p_path,HashMap<String,TreeItem*>& item_paths,TreeItem *root);
-	
+
 	void set_item_text(TreeItem *p_item, int p_type, const String& p_name, int p_hint=PROPERTY_HINT_NONE, const String& p_hint_text="");
-		
+
 	TreeItem *find_item(TreeItem *p_item,const String& p_name);
-		
-	
+
+
 	virtual void _changed_callback(Object *p_changed,const char * p_what);
 	virtual void _changed_callbacks(Object *p_changed,const String& p_callback);
 
 	void _edit_button(Object *p_item, int p_column, int p_button);
-	
+
 	void _node_removed(Node *p_node);
 	void _edit_set(const String& p_name, const Variant& p_value);
 	void _draw_flags(Object *ti,const Rect2& p_rect);
@@ -191,7 +193,7 @@ class PropertyEditor : public Control {
 
 	UndoRedo *undo_redo;
 protected:
-	
+
 	void _notification(int p_what);
 	static void _bind_methods();
 public:
@@ -217,8 +219,8 @@ public:
 	void set_autoclear(bool p_enable);
 
 	void set_show_categories(bool p_show);
-	
-	PropertyEditor();	
+
+	PropertyEditor();
 	~PropertyEditor();
 
 };
-- 
cgit v1.2.3


From a19a653e2cae50f43b8de5d4ba69170c7d2fa800 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sun, 30 Aug 2015 02:44:49 -0300
Subject: Compile shaders using default values.

---
 tools/editor/plugins/shader_graph_editor_plugin.cpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 12a9dce6b7..5da287aa69 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -2416,15 +2416,9 @@ void ShaderGraphView::_create_node(int p_id) {
 		Array reals;
 		reals.push_back("Alpha");
 		reals.push_back("NormapMapDepth");
+		reals.push_back("SpecExp");
 		reals.push_back("LightAlpha");
 		reals.push_back("PointSize");
-		Array vectors;
-		vectors.push_back("Normal");
-		vectors.push_back("NormalMap");
-		vectors.push_back("Vertex");
-		vectors.push_back("UV");
-		vectors.push_back("Var1");
-		vectors.push_back("Var2");
 
 		int idx=0;
 		for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
@@ -2435,7 +2429,7 @@ void ShaderGraphView::_create_node(int p_id) {
 					v=Variant::COLOR;
 				else if (reals.find(s.name)>=0)
 					v=Variant::REAL;
-				else if (vectors.find(s.name)>=0)
+				else
 					v=Variant::VECTOR3;
 				gn->add_child(make_label(s.name, v));
 				gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
-- 
cgit v1.2.3


From 680402cebf63066abcc93e7e8035e457c6305874 Mon Sep 17 00:00:00 2001
From: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Date: Sun, 30 Aug 2015 19:37:23 -0300
Subject: Add missing icons, also make MSVC2010 happy

---
 tools/editor/plugins/shader_graph_editor_plugin.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'tools/editor')

diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index 5da287aa69..1997b268a7 100644
--- a/tools/editor/plugins/shader_graph_editor_plugin.cpp
+++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp
@@ -2413,12 +2413,21 @@ void ShaderGraphView::_create_node(int p_id) {
 		Array colors;
 		colors.push_back("Color");
 		colors.push_back("LightColor");
+		colors.push_back("Light");
+		colors.push_back("Diffuse");
+		colors.push_back("Specular");
+		colors.push_back("Emmision");
 		Array reals;
 		reals.push_back("Alpha");
-		reals.push_back("NormapMapDepth");
+		reals.push_back("DiffuseAlpha");
+		reals.push_back("NormalMapDepth");
 		reals.push_back("SpecExp");
+		reals.push_back("Glow");
+		reals.push_back("ShadeParam");
+		reals.push_back("SpecularExp");
 		reals.push_back("LightAlpha");
 		reals.push_back("PointSize");
+		reals.push_back("Discard");
 
 		int idx=0;
 		for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
@@ -2739,10 +2748,8 @@ const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
 ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
 	_2d=p_2d;
 
-	HBoxContainer *hbc = memnew( HBoxContainer );
 	popup = memnew( PopupMenu );
-	hbc->add_child(popup);
-	add_child(hbc);
+	add_child(popup);
 
 
 	tabs = memnew(TabContainer);
-- 
cgit v1.2.3