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: [PATCH] Fix tab indent

---
 scene/gui/graph_edit.cpp                      |  884 ++--
 scene/gui/graph_edit.h                        |  112 +-
 scene/gui/graph_node.cpp                      |  660 +--
 scene/gui/graph_node.h                        |  126 +-
 .../resources/default_theme/default_theme.cpp |   90 +-
 .../plugins/shader_graph_editor_plugin.cpp    | 3730 ++++++++---------
 .../plugins/shader_graph_editor_plugin.h      |  232 +-
 7 files changed, 2917 insertions(+), 2917 deletions(-)

diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp
index 4569c71d0b6..22a03504c6e 100644
--- a/scene/gui/graph_edit.cpp
+++ b/scene/gui/graph_edit.cpp
@@ -3,385 +3,385 @@
 #include "os/keyboard.h"
 bool GraphEditFilter::has_point(const Point2& p_point) const {
 
-    return ge->_filter_input(p_point);
+	return ge->_filter_input(p_point);
 }
 
 
 GraphEditFilter::GraphEditFilter(GraphEdit *p_edit) {
 
-    ge=p_edit;
+	ge=p_edit;
 }
 
 
 Error GraphEdit::connect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port) {
 
-    if (is_node_connected(p_from,p_from_port,p_to,p_to_port))
-        return OK;
-    Connection c;
-    c.from=p_from;
-    c.from_port=p_from_port;
-    c.to=p_to;
-    c.to_port=p_to_port;
-    connections.push_back(c);
-    top_layer->update();
+	if (is_node_connected(p_from,p_from_port,p_to,p_to_port))
+		return OK;
+	Connection c;
+	c.from=p_from;
+	c.from_port=p_from_port;
+	c.to=p_to;
+	c.to_port=p_to_port;
+	connections.push_back(c);
+	top_layer->update();
 
-    return OK;
+	return OK;
 }
 
 bool GraphEdit::is_node_connected(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port) {
 
-    for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
+	for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
 
-        if (E->get().from==p_from && E->get().from_port==p_from_port && E->get().to==p_to && E->get().to_port==p_to_port)
-            return true;
-    }
+		if (E->get().from==p_from && E->get().from_port==p_from_port && E->get().to==p_to && E->get().to_port==p_to_port)
+			return true;
+	}
 
-    return false;
+	return false;
 
 }
 
 void GraphEdit::disconnect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port){
 
 
-    for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
+	for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
 
-        if (E->get().from==p_from && E->get().from_port==p_from_port && E->get().to==p_to && E->get().to_port==p_to_port) {
+		if (E->get().from==p_from && E->get().from_port==p_from_port && E->get().to==p_to && E->get().to_port==p_to_port) {
 
-            connections.erase(E);
-            top_layer->update();
-            return;
-        }
-    }
+			connections.erase(E);
+			top_layer->update();
+			return;
+		}
+	}
 }
 
 void GraphEdit::get_connection_list(List<Connection> *r_connections) const {
 
-    *r_connections=connections;
+	*r_connections=connections;
 }
 
 
 void GraphEdit::_scroll_moved(double) {
 
 
-    _update_scroll_offset();
-    top_layer->update();
+	_update_scroll_offset();
+	top_layer->update();
 }
 
 void GraphEdit::_update_scroll_offset() {
 
-    for(int i=0;i<get_child_count();i++) {
+	for(int i=0;i<get_child_count();i++) {
 
-        GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-        if (!gn)
-            continue;
+		GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+		if (!gn)
+			continue;
 
-        Point2 pos=gn->get_offset();
-        pos-=Point2(h_scroll->get_val(),v_scroll->get_val());
-        gn->set_pos(pos);
-    }
+		Point2 pos=gn->get_offset();
+		pos-=Point2(h_scroll->get_val(),v_scroll->get_val());
+		gn->set_pos(pos);
+	}
 
 }
 
 void GraphEdit::_update_scroll() {
 
-    if (updating)
-        return;
+	if (updating)
+		return;
 
-    updating=true;
-    Rect2 screen;
-    for(int i=0;i<get_child_count();i++) {
+	updating=true;
+	Rect2 screen;
+	for(int i=0;i<get_child_count();i++) {
 
-        GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-        if (!gn)
-            continue;
+		GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+		if (!gn)
+			continue;
 
-        Rect2 r;
-        r.pos=gn->get_offset();
-        r.size=gn->get_size();
-        screen = screen.merge(r);
-    }
+		Rect2 r;
+		r.pos=gn->get_offset();
+		r.size=gn->get_size();
+		screen = screen.merge(r);
+	}
 
-    screen.pos-=get_size();
-    screen.size+=get_size()*2.0;
+	screen.pos-=get_size();
+	screen.size+=get_size()*2.0;
 
 
-    h_scroll->set_min(screen.pos.x);
-    h_scroll->set_max(screen.pos.x+screen.size.x);
-    h_scroll->set_page(get_size().x);
-    if (h_scroll->get_max() - h_scroll->get_min() <= h_scroll->get_page())
-        h_scroll->hide();
-    else
-        h_scroll->show();
+	h_scroll->set_min(screen.pos.x);
+	h_scroll->set_max(screen.pos.x+screen.size.x);
+	h_scroll->set_page(get_size().x);
+	if (h_scroll->get_max() - h_scroll->get_min() <= h_scroll->get_page())
+		h_scroll->hide();
+	else
+		h_scroll->show();
 
-    v_scroll->set_min(screen.pos.y);
-    v_scroll->set_max(screen.pos.y+screen.size.y);
-    v_scroll->set_page(get_size().y);
+	v_scroll->set_min(screen.pos.y);
+	v_scroll->set_max(screen.pos.y+screen.size.y);
+	v_scroll->set_page(get_size().y);
 
-    if (v_scroll->get_max() - v_scroll->get_min() <= v_scroll->get_page())
-        v_scroll->hide();
-    else
-        v_scroll->show();
+	if (v_scroll->get_max() - v_scroll->get_min() <= v_scroll->get_page())
+		v_scroll->hide();
+	else
+		v_scroll->show();
 
-    _update_scroll_offset();
-    updating=false;
+	_update_scroll_offset();
+	updating=false;
 }
 
 
 void GraphEdit::_graph_node_raised(Node* p_gn) {
 
-    GraphNode *gn=p_gn->cast_to<GraphNode>();
-    ERR_FAIL_COND(!gn);
-    gn->raise();
-    top_layer->raise();
+	GraphNode *gn=p_gn->cast_to<GraphNode>();
+	ERR_FAIL_COND(!gn);
+	gn->raise();
+	top_layer->raise();
 
 }
 
 
 void GraphEdit::_graph_node_moved(Node *p_gn) {
 
-    GraphNode *gn=p_gn->cast_to<GraphNode>();
-    ERR_FAIL_COND(!gn);
-    top_layer->update();
+	GraphNode *gn=p_gn->cast_to<GraphNode>();
+	ERR_FAIL_COND(!gn);
+	top_layer->update();
 }
 
 void GraphEdit::add_child_notify(Node *p_child) {
 
-    top_layer->call_deferred("raise"); //top layer always on top!
-    GraphNode *gn = p_child->cast_to<GraphNode>();
-    if (gn) {
-        gn->connect("offset_changed",this,"_graph_node_moved",varray(gn));
-        gn->connect("raise_request",this,"_graph_node_raised",varray(gn));
-        _graph_node_moved(gn);
-        gn->set_stop_mouse(false);
-    }
+	top_layer->call_deferred("raise"); //top layer always on top!
+	GraphNode *gn = p_child->cast_to<GraphNode>();
+	if (gn) {
+		gn->connect("offset_changed",this,"_graph_node_moved",varray(gn));
+		gn->connect("raise_request",this,"_graph_node_raised",varray(gn));
+		_graph_node_moved(gn);
+		gn->set_stop_mouse(false);
+	}
 }
 
 void GraphEdit::remove_child_notify(Node *p_child) {
 
-    top_layer->call_deferred("raise"); //top layer always on top!
-    GraphNode *gn = p_child->cast_to<GraphNode>();
-    if (gn) {
-        gn->disconnect("offset_changed",this,"_graph_node_moved");
-        gn->disconnect("raise_request",this,"_graph_node_raised");
-    }
+	top_layer->call_deferred("raise"); //top layer always on top!
+	GraphNode *gn = p_child->cast_to<GraphNode>();
+	if (gn) {
+		gn->disconnect("offset_changed",this,"_graph_node_moved");
+		gn->disconnect("raise_request",this,"_graph_node_raised");
+	}
 }
 
 void GraphEdit::_notification(int p_what) {
 
-    if (p_what==NOTIFICATION_READY) {
-        Size2 size = top_layer->get_size();
-        Size2 hmin = h_scroll->get_combined_minimum_size();
-        Size2 vmin = v_scroll->get_combined_minimum_size();
+	if (p_what==NOTIFICATION_READY) {
+		Size2 size = top_layer->get_size();
+		Size2 hmin = h_scroll->get_combined_minimum_size();
+		Size2 vmin = v_scroll->get_combined_minimum_size();
 
-        v_scroll->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,vmin.width);
-        v_scroll->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0);
-        v_scroll->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,0);
-        v_scroll->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0);
+		v_scroll->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,vmin.width);
+		v_scroll->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0);
+		v_scroll->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,0);
+		v_scroll->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0);
 
-        h_scroll->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,0);
-        h_scroll->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0);
-        h_scroll->set_anchor_and_margin(MARGIN_TOP,ANCHOR_END,hmin.height);
-        h_scroll->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0);
+		h_scroll->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,0);
+		h_scroll->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0);
+		h_scroll->set_anchor_and_margin(MARGIN_TOP,ANCHOR_END,hmin.height);
+		h_scroll->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0);
 
-    }
-    if (p_what==NOTIFICATION_DRAW) {
-        VS::get_singleton()->canvas_item_set_clip(get_canvas_item(),true);
+	}
+	if (p_what==NOTIFICATION_DRAW) {
+		VS::get_singleton()->canvas_item_set_clip(get_canvas_item(),true);
 
-    }
+	}
 
-    if (p_what==NOTIFICATION_RESIZED) {
-        _update_scroll();
-        top_layer->update();
-    }
+	if (p_what==NOTIFICATION_RESIZED) {
+		_update_scroll();
+		top_layer->update();
+	}
 }
 
 bool GraphEdit::_filter_input(const Point2& p_point) {
 
-    Ref<Texture> port =get_icon("port","GraphNode");
+	Ref<Texture> port =get_icon("port","GraphNode");
 
-    float grab_r=port->get_width()*0.5;
-    for(int i=get_child_count()-1;i>=0;i--) {
+	float grab_r=port->get_width()*0.5;
+	for(int i=get_child_count()-1;i>=0;i--) {
 
-        GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-        if (!gn)
-            continue;
+		GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+		if (!gn)
+			continue;
 
-        for(int j=0;j<gn->get_connection_output_count();j++) {
+		for(int j=0;j<gn->get_connection_output_count();j++) {
 
-            Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
-            if (pos.distance_to(p_point)<grab_r)
-                return true;
+			Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
+			if (pos.distance_to(p_point)<grab_r)
+				return true;
 
 
-        }
+		}
 
-        for(int j=0;j<gn->get_connection_input_count();j++) {
+		for(int j=0;j<gn->get_connection_input_count();j++) {
 
-            Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
-            if (pos.distance_to(p_point)<grab_r)
-                return true;
+			Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
+			if (pos.distance_to(p_point)<grab_r)
+				return true;
 
 
-        }
+		}
 
-    }
+	}
 
-    return false;
+	return false;
 }
 
 void GraphEdit::_top_layer_input(const InputEvent& p_ev) {
 
-    if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index==BUTTON_LEFT && p_ev.mouse_button.pressed) {
+	if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index==BUTTON_LEFT && p_ev.mouse_button.pressed) {
 
-        Ref<Texture> port =get_icon("port","GraphNode");
-        Vector2 mpos(p_ev.mouse_button.x,p_ev.mouse_button.y);
-        float grab_r=port->get_width()*0.5;
-        for(int i=get_child_count()-1;i>=0;i--) {
+		Ref<Texture> port =get_icon("port","GraphNode");
+		Vector2 mpos(p_ev.mouse_button.x,p_ev.mouse_button.y);
+		float grab_r=port->get_width()*0.5;
+		for(int i=get_child_count()-1;i>=0;i--) {
 
-            GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-            if (!gn)
-                continue;
+			GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+			if (!gn)
+				continue;
 
-            for(int j=0;j<gn->get_connection_output_count();j++) {
+			for(int j=0;j<gn->get_connection_output_count();j++) {
 
-                Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
-                if (pos.distance_to(mpos)<grab_r) {
+				Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
+				if (pos.distance_to(mpos)<grab_r) {
 
-                    connecting=true;
-                    connecting_from=gn->get_name();
-                    connecting_index=j;
-                    connecting_out=true;
-                    connecting_type=gn->get_connection_output_type(j);
-                    connecting_color=gn->get_connection_output_color(j);
-                    connecting_target=false;
-                    connecting_to=pos;
-                    return;
-                }
+					connecting=true;
+					connecting_from=gn->get_name();
+					connecting_index=j;
+					connecting_out=true;
+					connecting_type=gn->get_connection_output_type(j);
+					connecting_color=gn->get_connection_output_color(j);
+					connecting_target=false;
+					connecting_to=pos;
+					return;
+				}
 
 
-            }
+			}
 
-            for(int j=0;j<gn->get_connection_input_count();j++) {
+			for(int j=0;j<gn->get_connection_input_count();j++) {
 
-                Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
+				Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
 
-                if (pos.distance_to(mpos)<grab_r) {
+				if (pos.distance_to(mpos)<grab_r) {
 
-                    if (right_disconnects) {
-                        //check disconnect
-                        for (List<Connection>::Element*E=connections.front();E;E=E->next()) {
+					if (right_disconnects) {
+						//check disconnect
+						for (List<Connection>::Element*E=connections.front();E;E=E->next()) {
 
-                            if (E->get().to==gn->get_name() && E->get().to_port==j) {
+							if (E->get().to==gn->get_name() && E->get().to_port==j) {
 
-                                Node*fr = get_node(String(E->get().from));
-                                if (fr && fr->cast_to<GraphNode>()) {
+								Node*fr = get_node(String(E->get().from));
+								if (fr && fr->cast_to<GraphNode>()) {
 
-                                    connecting_from=E->get().from;
-                                    connecting_index=E->get().from_port;
-                                    connecting_out=true;
-                                    connecting_type=fr->cast_to<GraphNode>()->get_connection_output_type(E->get().from_port);
-                                    connecting_color=fr->cast_to<GraphNode>()->get_connection_output_color(E->get().from_port);
-                                    connecting_target=false;
-                                    connecting_to=pos;
+									connecting_from=E->get().from;
+									connecting_index=E->get().from_port;
+									connecting_out=true;
+									connecting_type=fr->cast_to<GraphNode>()->get_connection_output_type(E->get().from_port);
+									connecting_color=fr->cast_to<GraphNode>()->get_connection_output_color(E->get().from_port);
+									connecting_target=false;
+									connecting_to=pos;
 
-                                    emit_signal("disconnection_request",E->get().from,E->get().from_port,E->get().to,E->get().to_port);
-                                    fr = get_node(String(connecting_from)); //maybe it was erased
-                                    if (fr && fr->cast_to<GraphNode>()) {
-                                        connecting=true;
-                                    }
-                                    return;
-                                }
+									emit_signal("disconnection_request",E->get().from,E->get().from_port,E->get().to,E->get().to_port);
+									fr = get_node(String(connecting_from)); //maybe it was erased
+									if (fr && fr->cast_to<GraphNode>()) {
+										connecting=true;
+									}
+									return;
+								}
 
-                            }
-                        }
-                    }
+							}
+						}
+					}
 
 
-                    connecting=true;
-                    connecting_from=gn->get_name();
-                    connecting_index=j;
-                    connecting_out=false;
-                    connecting_type=gn->get_connection_input_type(j);
-                    connecting_color=gn->get_connection_input_color(j);
-                    connecting_target=false;
-                    connecting_to=pos;
-                    return;
-                }
+					connecting=true;
+					connecting_from=gn->get_name();
+					connecting_index=j;
+					connecting_out=false;
+					connecting_type=gn->get_connection_input_type(j);
+					connecting_color=gn->get_connection_input_color(j);
+					connecting_target=false;
+					connecting_to=pos;
+					return;
+				}
 
 
-            }
-        }
-    }
+			}
+		}
+	}
 
-    if (p_ev.type==InputEvent::MOUSE_MOTION && connecting) {
+	if (p_ev.type==InputEvent::MOUSE_MOTION && connecting) {
 
-        connecting_to=Vector2(p_ev.mouse_motion.x,p_ev.mouse_motion.y);
-        connecting_target=false;
-        top_layer->update();
+		connecting_to=Vector2(p_ev.mouse_motion.x,p_ev.mouse_motion.y);
+		connecting_target=false;
+		top_layer->update();
 
-        Ref<Texture> port =get_icon("port","GraphNode");
-        Vector2 mpos(p_ev.mouse_button.x,p_ev.mouse_button.y);
-        float grab_r=port->get_width()*0.5;
-        for(int i=get_child_count()-1;i>=0;i--) {
+		Ref<Texture> port =get_icon("port","GraphNode");
+		Vector2 mpos(p_ev.mouse_button.x,p_ev.mouse_button.y);
+		float grab_r=port->get_width()*0.5;
+		for(int i=get_child_count()-1;i>=0;i--) {
 
-            GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-            if (!gn)
-                continue;
+			GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+			if (!gn)
+				continue;
 
-            if (!connecting_out) {
-                for(int j=0;j<gn->get_connection_output_count();j++) {
+			if (!connecting_out) {
+				for(int j=0;j<gn->get_connection_output_count();j++) {
 
-                    Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
-                    int type =gn->get_connection_output_type(j);
-                    if (type==connecting_type && pos.distance_to(mpos)<grab_r) {
+					Vector2 pos = gn->get_connection_output_pos(j)+gn->get_pos();
+					int type =gn->get_connection_output_type(j);
+					if (type==connecting_type && pos.distance_to(mpos)<grab_r) {
 
-                        connecting_target=true;
-                        connecting_to=pos;
-                        connecting_target_to=gn->get_name();
-                        connecting_target_index=j;
-                        return;
-                    }
+						connecting_target=true;
+						connecting_to=pos;
+						connecting_target_to=gn->get_name();
+						connecting_target_index=j;
+						return;
+					}
 
 
-                }
-            } else {
+				}
+			} else {
 
-                for(int j=0;j<gn->get_connection_input_count();j++) {
+				for(int j=0;j<gn->get_connection_input_count();j++) {
 
-                    Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
-                    int type =gn->get_connection_input_type(j);
-                    if (type==connecting_type && pos.distance_to(mpos)<grab_r) {
-                        connecting_target=true;
-                        connecting_to=pos;
-                        connecting_target_to=gn->get_name();
-                        connecting_target_index=j;
-                        return;
-                    }
-                }
-            }
-        }
-    }
+					Vector2 pos = gn->get_connection_input_pos(j)+gn->get_pos();
+					int type =gn->get_connection_input_type(j);
+					if (type==connecting_type && pos.distance_to(mpos)<grab_r) {
+						connecting_target=true;
+						connecting_to=pos;
+						connecting_target_to=gn->get_name();
+						connecting_target_index=j;
+						return;
+					}
+				}
+			}
+		}
+	}
 
-    if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index==BUTTON_LEFT && !p_ev.mouse_button.pressed) {
+	if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index==BUTTON_LEFT && !p_ev.mouse_button.pressed) {
 
-        if (connecting && connecting_target) {
+		if (connecting && connecting_target) {
 
-            String from = connecting_from;
-            int from_slot = connecting_index;
-            String to =connecting_target_to;
-            int to_slot = connecting_target_index;
+			String from = connecting_from;
+			int from_slot = connecting_index;
+			String to =connecting_target_to;
+			int to_slot = connecting_target_index;
 
-            if (!connecting_out) {
-                SWAP(from,to);
-                SWAP(from_slot,to_slot);
-            }
-            emit_signal("connection_request",from,from_slot,to,to_slot);
+			if (!connecting_out) {
+				SWAP(from,to);
+				SWAP(from_slot,to_slot);
+			}
+			emit_signal("connection_request",from,from_slot,to,to_slot);
 
-        }
-        connecting=false;
-        top_layer->update();
+		}
+		connecting=false;
+		top_layer->update();
 
-    }
+	}
 
 
 
@@ -389,295 +389,295 @@ void GraphEdit::_top_layer_input(const InputEvent& p_ev) {
 
 void GraphEdit::_draw_cos_line(const Vector2& p_from, const Vector2& p_to,const Color& p_color) {
 
-    static const int steps = 20;
+	static const int steps = 20;
 
-    Rect2 r;
-    r.pos=p_from;
-    r.expand_to(p_to);
-    Vector2 sign=Vector2((p_from.x < p_to.x) ? 1 : -1,(p_from.y < p_to.y) ? 1 : -1);
-    bool flip = sign.x * sign.y < 0;
+	Rect2 r;
+	r.pos=p_from;
+	r.expand_to(p_to);
+	Vector2 sign=Vector2((p_from.x < p_to.x) ? 1 : -1,(p_from.y < p_to.y) ? 1 : -1);
+	bool flip = sign.x * sign.y < 0;
 
-    Vector2 prev;
-    for(int i=0;i<=steps;i++) {
+	Vector2 prev;
+	for(int i=0;i<=steps;i++) {
 
-        float d = i/float(steps);
-        float c=-Math::cos(d*Math_PI) * 0.5+0.5;
-        if (flip)
-            c=1.0-c;
-        Vector2 p = r.pos+Vector2(d*r.size.width,c*r.size.height);
+		float d = i/float(steps);
+		float c=-Math::cos(d*Math_PI) * 0.5+0.5;
+		if (flip)
+			c=1.0-c;
+		Vector2 p = r.pos+Vector2(d*r.size.width,c*r.size.height);
 
-        if (i>0) {
+		if (i>0) {
 
-            top_layer->draw_line(prev,p,p_color,2);
-        }
+			top_layer->draw_line(prev,p,p_color,2);
+		}
 
-        prev=p;
-    }
+		prev=p;
+	}
 }
 
 void GraphEdit::_top_layer_draw() {
 
-    _update_scroll();
+	_update_scroll();
 
-    if (connecting) {
+	if (connecting) {
 
-        Node *fromn = get_node(connecting_from);
-        ERR_FAIL_COND(!fromn);
-        GraphNode *from = fromn->cast_to<GraphNode>();
-        ERR_FAIL_COND(!from);
-        Vector2 pos;
-        if (connecting_out)
-            pos=from->get_connection_output_pos(connecting_index);
-        else
-            pos=from->get_connection_input_pos(connecting_index);
-        pos+=from->get_pos();
+		Node *fromn = get_node(connecting_from);
+		ERR_FAIL_COND(!fromn);
+		GraphNode *from = fromn->cast_to<GraphNode>();
+		ERR_FAIL_COND(!from);
+		Vector2 pos;
+		if (connecting_out)
+			pos=from->get_connection_output_pos(connecting_index);
+		else
+			pos=from->get_connection_input_pos(connecting_index);
+		pos+=from->get_pos();
 
-        Vector2 topos;
-        topos=connecting_to;
+		Vector2 topos;
+		topos=connecting_to;
 
-        Color col=connecting_color;
+		Color col=connecting_color;
 
-        if (connecting_target) {
-            col.r+=0.4;
-            col.g+=0.4;
-            col.b+=0.4;
-        }
-        _draw_cos_line(pos,topos,col);
-    }
+		if (connecting_target) {
+			col.r+=0.4;
+			col.g+=0.4;
+			col.b+=0.4;
+		}
+		_draw_cos_line(pos,topos,col);
+	}
 
-    List<List<Connection>::Element* > to_erase;
-    for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
+	List<List<Connection>::Element* > to_erase;
+	for(List<Connection>::Element *E=connections.front();E;E=E->next()) {
 
-        NodePath fromnp(E->get().from);
+		NodePath fromnp(E->get().from);
 
-        Node * from = get_node(fromnp);
-        if (!from) {
-            to_erase.push_back(E);
-            continue;
-        }
+		Node * from = get_node(fromnp);
+		if (!from) {
+			to_erase.push_back(E);
+			continue;
+		}
 
-        GraphNode *gfrom = from->cast_to<GraphNode>();
+		GraphNode *gfrom = from->cast_to<GraphNode>();
 
-        if (!gfrom) {
-            to_erase.push_back(E);
-            continue;
-        }
+		if (!gfrom) {
+			to_erase.push_back(E);
+			continue;
+		}
 
-        NodePath tonp(E->get().to);
-        Node * to = get_node(tonp);
-        if (!to) {
-            to_erase.push_back(E);
-            continue;
-        }
+		NodePath tonp(E->get().to);
+		Node * to = get_node(tonp);
+		if (!to) {
+			to_erase.push_back(E);
+			continue;
+		}
 
-        GraphNode *gto = to->cast_to<GraphNode>();
+		GraphNode *gto = to->cast_to<GraphNode>();
 
-        if (!gto) {
-            to_erase.push_back(E);
-            continue;
-        }
+		if (!gto) {
+			to_erase.push_back(E);
+			continue;
+		}
 
-        Vector2 frompos=gfrom->get_connection_output_pos(E->get().from_port)+gfrom->get_pos();
-        Color color = gfrom->get_connection_output_color(E->get().from_port);
-        Vector2 topos=gto->get_connection_input_pos(E->get().to_port)+gto->get_pos();
-        _draw_cos_line(frompos,topos,color);
+		Vector2 frompos=gfrom->get_connection_output_pos(E->get().from_port)+gfrom->get_pos();
+		Color color = gfrom->get_connection_output_color(E->get().from_port);
+		Vector2 topos=gto->get_connection_input_pos(E->get().to_port)+gto->get_pos();
+		_draw_cos_line(frompos,topos,color);
 
-    }
+	}
 
-    while(to_erase.size()) {
-        connections.erase(to_erase.front()->get());
-        to_erase.pop_front();
-    }
-    //draw connections
+	while(to_erase.size()) {
+		connections.erase(to_erase.front()->get());
+		to_erase.pop_front();
+	}
+	//draw connections
 }
 
 void GraphEdit::_input_event(const InputEvent& p_ev) {
 
-    if (p_ev.type==InputEvent::MOUSE_MOTION && (p_ev.mouse_motion.button_mask&BUTTON_MASK_MIDDLE || (p_ev.mouse_motion.button_mask&BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE)))) {
-        h_scroll->set_val( h_scroll->get_val() - p_ev.mouse_motion.relative_x );
-        v_scroll->set_val( v_scroll->get_val() - p_ev.mouse_motion.relative_y );
-    }
+	if (p_ev.type==InputEvent::MOUSE_MOTION && (p_ev.mouse_motion.button_mask&BUTTON_MASK_MIDDLE || (p_ev.mouse_motion.button_mask&BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE)))) {
+		h_scroll->set_val( h_scroll->get_val() - p_ev.mouse_motion.relative_x );
+		v_scroll->set_val( v_scroll->get_val() - p_ev.mouse_motion.relative_y );
+	}
 
-    if (p_ev.type==InputEvent::MOUSE_MOTION && dragging) {
+	if (p_ev.type==InputEvent::MOUSE_MOTION && dragging) {
 
-        just_selected=true;
-        drag_accum+=Vector2(p_ev.mouse_motion.relative_x,p_ev.mouse_motion.relative_y);
-        for(int i=get_child_count()-1;i>=0;i--) {
-            GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-            if (gn && gn->is_selected())
-                gn->set_offset(gn->get_drag_from()+drag_accum);
-        }
-    }
+		just_selected=true;
+		drag_accum+=Vector2(p_ev.mouse_motion.relative_x,p_ev.mouse_motion.relative_y);
+		for(int i=get_child_count()-1;i>=0;i--) {
+			GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+			if (gn && gn->is_selected())
+				gn->set_offset(gn->get_drag_from()+drag_accum);
+		}
+	}
 
-    if (p_ev.type== InputEvent::MOUSE_BUTTON) {
+	if (p_ev.type== InputEvent::MOUSE_BUTTON) {
 
-        const InputEventMouseButton &b=p_ev.mouse_button;
+		const InputEventMouseButton &b=p_ev.mouse_button;
 
-        if (b.button_index==BUTTON_RIGHT && b.pressed)
-        {
-            emit_signal("popup_request", Vector2(b.global_x, b.global_y));
-        }
+		if (b.button_index==BUTTON_RIGHT && b.pressed)
+		{
+			emit_signal("popup_request", Vector2(b.global_x, b.global_y));
+		}
 
-        if (b.button_index==BUTTON_LEFT && !b.pressed && dragging) {
-            if (!just_selected && drag_accum==Vector2() && Input::get_singleton()->is_key_pressed(KEY_CONTROL)) {
-                //deselect current node
-                for(int i=get_child_count()-1;i>=0;i--) {
-                    GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+		if (b.button_index==BUTTON_LEFT && !b.pressed && dragging) {
+			if (!just_selected && drag_accum==Vector2() && Input::get_singleton()->is_key_pressed(KEY_CONTROL)) {
+				//deselect current node
+				for(int i=get_child_count()-1;i>=0;i--) {
+					GraphNode *gn=get_child(i)->cast_to<GraphNode>();
 
-                    if (gn && gn->get_rect().has_point(get_local_mouse_pos()))
-                        gn->set_selected(false);
-                }
-            }
+					if (gn && gn->get_rect().has_point(get_local_mouse_pos()))
+						gn->set_selected(false);
+				}
+			}
 
-            if (drag_accum!=Vector2()) {
+			if (drag_accum!=Vector2()) {
 
-                emit_signal("_begin_node_move");
+				emit_signal("_begin_node_move");
 
-                for(int i=get_child_count()-1;i>=0;i--) {
-                    GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-                    if (gn && gn->is_selected())
-                        gn->set_drag(false);
-                }
+				for(int i=get_child_count()-1;i>=0;i--) {
+					GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+					if (gn && gn->is_selected())
+						gn->set_drag(false);
+				}
 
-                emit_signal("_end_node_move");
-            }
+				emit_signal("_end_node_move");
+			}
 
-            dragging = false;
+			dragging = false;
 
-            top_layer->update();
-        }
+			top_layer->update();
+		}
 
-        if (b.button_index==BUTTON_LEFT && b.pressed) {
+		if (b.button_index==BUTTON_LEFT && b.pressed) {
 
-            GraphNode *gn;
-            for(int i=get_child_count()-1;i>=0;i--) {
+			GraphNode *gn;
+			for(int i=get_child_count()-1;i>=0;i--) {
 
-                gn=get_child(i)->cast_to<GraphNode>();
+				gn=get_child(i)->cast_to<GraphNode>();
 
-                if (gn && gn->get_rect().has_point(get_local_mouse_pos()))
-                    break;
-            }
+				if (gn && gn->get_rect().has_point(get_local_mouse_pos()))
+					break;
+			}
 
-            if (gn) {
+			if (gn) {
 
-                if (_filter_input(Vector2(b.x,b.y)))
-                    return;
+				if (_filter_input(Vector2(b.x,b.y)))
+					return;
 
-                dragging = true;
-                drag_accum = Vector2();
-                just_selected = !gn->is_selected();
-                if(!gn->is_selected() && !Input::get_singleton()->is_key_pressed(KEY_CONTROL)) {
-                    for (int i = 0; i < get_child_count(); i++) {
-                        GraphNode *o_gn = get_child(i)->cast_to<GraphNode>();
-                        if (o_gn)
-                            o_gn->set_selected(o_gn == gn);
-                    }
-                }
+				dragging = true;
+				drag_accum = Vector2();
+				just_selected = !gn->is_selected();
+				if(!gn->is_selected() && !Input::get_singleton()->is_key_pressed(KEY_CONTROL)) {
+					for (int i = 0; i < get_child_count(); i++) {
+						GraphNode *o_gn = get_child(i)->cast_to<GraphNode>();
+						if (o_gn)
+							o_gn->set_selected(o_gn == gn);
+					}
+				}
 
-                gn->set_selected(true);
-                for (int i = 0; i < get_child_count(); i++) {
-                    GraphNode *o_gn = get_child(i)->cast_to<GraphNode>();
-                    if (!o_gn)
-                        continue;
-                    if (o_gn->is_selected())
-                        o_gn->set_drag(true);
-                }
+				gn->set_selected(true);
+				for (int i = 0; i < get_child_count(); i++) {
+					GraphNode *o_gn = get_child(i)->cast_to<GraphNode>();
+					if (!o_gn)
+						continue;
+					if (o_gn->is_selected())
+						o_gn->set_drag(true);
+				}
 
-            } else {
-                for(int i=get_child_count()-1;i>=0;i--) {
+			} else {
+				for(int i=get_child_count()-1;i>=0;i--) {
 
-                    GraphNode *gn=get_child(i)->cast_to<GraphNode>();
-                    if (!gn)
-                        continue;
+					GraphNode *gn=get_child(i)->cast_to<GraphNode>();
+					if (!gn)
+						continue;
 
-                    gn->set_selected(false);
-                }
-            }
-        }
-    }
+					gn->set_selected(false);
+				}
+			}
+		}
+	}
 }
 
 void GraphEdit::clear_connections() {
 
-    connections.clear();
-    update();
+	connections.clear();
+	update();
 }
 
 
 void GraphEdit::set_right_disconnects(bool p_enable) {
 
-    right_disconnects=p_enable;
+	right_disconnects=p_enable;
 }
 
 bool GraphEdit::is_right_disconnects_enabled() const{
 
-    return right_disconnects;
+	return right_disconnects;
 }
 
 Array GraphEdit::_get_connection_list() const {
 
-    List<Connection> conns;
-    get_connection_list(&conns);
-    Array arr;
-    for(List<Connection>::Element *E=conns.front();E;E=E->next()) {
-        Dictionary d;
-        d["from"]=E->get().from;
-        d["from_port"]=E->get().from_port;
-        d["to"]=E->get().to;
-        d["to_port"]=E->get().to_port;
-        arr.push_back(d);
-    }
-    return arr;
+	List<Connection> conns;
+	get_connection_list(&conns);
+	Array arr;
+	for(List<Connection>::Element *E=conns.front();E;E=E->next()) {
+		Dictionary d;
+		d["from"]=E->get().from;
+		d["from_port"]=E->get().from_port;
+		d["to"]=E->get().to;
+		d["to_port"]=E->get().to_port;
+		arr.push_back(d);
+	}
+	return arr;
 }
 void GraphEdit::_bind_methods() {
 
-    ObjectTypeDB::bind_method(_MD("connect_node:Error","from","from_port","to","to_port"),&GraphEdit::connect_node);
-    ObjectTypeDB::bind_method(_MD("is_node_connected","from","from_port","to","to_port"),&GraphEdit::is_node_connected);
-    ObjectTypeDB::bind_method(_MD("disconnect_node","from","from_port","to","to_port"),&GraphEdit::disconnect_node);
-    ObjectTypeDB::bind_method(_MD("get_connection_list"),&GraphEdit::_get_connection_list);
+	ObjectTypeDB::bind_method(_MD("connect_node:Error","from","from_port","to","to_port"),&GraphEdit::connect_node);
+	ObjectTypeDB::bind_method(_MD("is_node_connected","from","from_port","to","to_port"),&GraphEdit::is_node_connected);
+	ObjectTypeDB::bind_method(_MD("disconnect_node","from","from_port","to","to_port"),&GraphEdit::disconnect_node);
+	ObjectTypeDB::bind_method(_MD("get_connection_list"),&GraphEdit::_get_connection_list);
 
-    ObjectTypeDB::bind_method(_MD("set_right_disconnects","enable"),&GraphEdit::set_right_disconnects);
-    ObjectTypeDB::bind_method(_MD("is_right_disconnects_enabled"),&GraphEdit::is_right_disconnects_enabled);
+	ObjectTypeDB::bind_method(_MD("set_right_disconnects","enable"),&GraphEdit::set_right_disconnects);
+	ObjectTypeDB::bind_method(_MD("is_right_disconnects_enabled"),&GraphEdit::is_right_disconnects_enabled);
 
-    ObjectTypeDB::bind_method(_MD("_graph_node_moved"),&GraphEdit::_graph_node_moved);
-    ObjectTypeDB::bind_method(_MD("_graph_node_raised"),&GraphEdit::_graph_node_raised);
+	ObjectTypeDB::bind_method(_MD("_graph_node_moved"),&GraphEdit::_graph_node_moved);
+	ObjectTypeDB::bind_method(_MD("_graph_node_raised"),&GraphEdit::_graph_node_raised);
 
-    ObjectTypeDB::bind_method(_MD("_top_layer_input"),&GraphEdit::_top_layer_input);
-    ObjectTypeDB::bind_method(_MD("_top_layer_draw"),&GraphEdit::_top_layer_draw);
-    ObjectTypeDB::bind_method(_MD("_scroll_moved"),&GraphEdit::_scroll_moved);
+	ObjectTypeDB::bind_method(_MD("_top_layer_input"),&GraphEdit::_top_layer_input);
+	ObjectTypeDB::bind_method(_MD("_top_layer_draw"),&GraphEdit::_top_layer_draw);
+	ObjectTypeDB::bind_method(_MD("_scroll_moved"),&GraphEdit::_scroll_moved);
 
-    ObjectTypeDB::bind_method(_MD("_input_event"),&GraphEdit::_input_event);
+	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphEdit::_input_event);
 
-    ADD_SIGNAL(MethodInfo("connection_request",PropertyInfo(Variant::STRING,"from"),PropertyInfo(Variant::INT,"from_slot"),PropertyInfo(Variant::STRING,"to"),PropertyInfo(Variant::INT,"to_slot")));
-    ADD_SIGNAL(MethodInfo("disconnection_request",PropertyInfo(Variant::STRING,"from"),PropertyInfo(Variant::INT,"from_slot"),PropertyInfo(Variant::STRING,"to"),PropertyInfo(Variant::INT,"to_slot")));
-    ADD_SIGNAL(MethodInfo("popup_request", PropertyInfo(Variant::VECTOR2,"p_position")));
-    ADD_SIGNAL(MethodInfo("_begin_node_move"));
-    ADD_SIGNAL(MethodInfo("_end_node_move"));
+	ADD_SIGNAL(MethodInfo("connection_request",PropertyInfo(Variant::STRING,"from"),PropertyInfo(Variant::INT,"from_slot"),PropertyInfo(Variant::STRING,"to"),PropertyInfo(Variant::INT,"to_slot")));
+	ADD_SIGNAL(MethodInfo("disconnection_request",PropertyInfo(Variant::STRING,"from"),PropertyInfo(Variant::INT,"from_slot"),PropertyInfo(Variant::STRING,"to"),PropertyInfo(Variant::INT,"to_slot")));
+	ADD_SIGNAL(MethodInfo("popup_request", PropertyInfo(Variant::VECTOR2,"p_position")));
+	ADD_SIGNAL(MethodInfo("_begin_node_move"));
+	ADD_SIGNAL(MethodInfo("_end_node_move"));
 }
 
 
 
 GraphEdit::GraphEdit() {
-    top_layer=NULL;
-    top_layer=memnew(GraphEditFilter(this));
-    add_child(top_layer);
-    top_layer->set_stop_mouse(false);
-    top_layer->set_area_as_parent_rect();
-    top_layer->connect("draw",this,"_top_layer_draw");
+	top_layer=NULL;
+	top_layer=memnew(GraphEditFilter(this));
+	add_child(top_layer);
 	top_layer->set_stop_mouse(false);
-    top_layer->connect("input_event",this,"_top_layer_input");
+	top_layer->set_area_as_parent_rect();
+	top_layer->connect("draw",this,"_top_layer_draw");
+	top_layer->set_stop_mouse(false);
+	top_layer->connect("input_event",this,"_top_layer_input");
 
-    h_scroll = memnew(HScrollBar);
-    h_scroll->set_name("_h_scroll");
-    top_layer->add_child(h_scroll);
+	h_scroll = memnew(HScrollBar);
+	h_scroll->set_name("_h_scroll");
+	top_layer->add_child(h_scroll);
 
-    v_scroll = memnew(VScrollBar);
-    v_scroll->set_name("_v_scroll");
-    top_layer->add_child(v_scroll);
-    updating=false;
-    connecting=false;
-    right_disconnects=false;
+	v_scroll = memnew(VScrollBar);
+	v_scroll->set_name("_v_scroll");
+	top_layer->add_child(v_scroll);
+	updating=false;
+	connecting=false;
+	right_disconnects=false;
 
-    h_scroll->connect("value_changed", this,"_scroll_moved");
-    v_scroll->connect("value_changed", this,"_scroll_moved");
+	h_scroll->connect("value_changed", this,"_scroll_moved");
+	v_scroll->connect("value_changed", this,"_scroll_moved");
 }
diff --git a/scene/gui/graph_edit.h b/scene/gui/graph_edit.h
index 2f9a5fc954e..5ab0f3300eb 100644
--- a/scene/gui/graph_edit.h
+++ b/scene/gui/graph_edit.h
@@ -8,95 +8,95 @@ class GraphEdit;
 
 class GraphEditFilter : public Control {
 
-    OBJ_TYPE(GraphEditFilter,Control);
+	OBJ_TYPE(GraphEditFilter,Control);
 
-friend class GraphEdit;
-    GraphEdit *ge;
-    virtual bool has_point(const Point2& p_point) const;
+	friend class GraphEdit;
+	GraphEdit *ge;
+	virtual bool has_point(const Point2& p_point) const;
 
 public:
 
 
-    GraphEditFilter(GraphEdit *p_edit);
+	GraphEditFilter(GraphEdit *p_edit);
 };
 
 class GraphEdit : public Control {
 
-    OBJ_TYPE(GraphEdit,Control);
+	OBJ_TYPE(GraphEdit,Control);
 public:
 
-    struct Connection {
-        StringName from;
-        StringName to;
-        int from_port;
-        int to_port;
+	struct Connection {
+		StringName from;
+		StringName to;
+		int from_port;
+		int to_port;
 
-    };
+	};
 private:
 
-    HScrollBar* h_scroll;
-    VScrollBar* v_scroll;
+	HScrollBar* h_scroll;
+	VScrollBar* v_scroll;
 
 
-    bool connecting;
-    String connecting_from;
-    bool connecting_out;
-    int connecting_index;
-    int connecting_type;
-    Color connecting_color;
-    bool connecting_target;
-    Vector2 connecting_to;
-    String connecting_target_to;
-    int connecting_target_index;
+	bool connecting;
+	String connecting_from;
+	bool connecting_out;
+	int connecting_index;
+	int connecting_type;
+	Color connecting_color;
+	bool connecting_target;
+	Vector2 connecting_to;
+	String connecting_target_to;
+	int connecting_target_index;
 
-    bool dragging;
-    bool just_selected;
-    Vector2 drag_accum;
+	bool dragging;
+	bool just_selected;
+	Vector2 drag_accum;
 
-    bool right_disconnects;
-    bool updating;
-    List<Connection> connections;
+	bool right_disconnects;
+	bool updating;
+	List<Connection> connections;
 
-    void _draw_cos_line(const Vector2& p_from, const Vector2& p_to,const Color& p_color);
+	void _draw_cos_line(const Vector2& p_from, const Vector2& p_to,const Color& p_color);
 
-    void _graph_node_raised(Node* p_gn);
-    void _graph_node_moved(Node *p_gn);
+	void _graph_node_raised(Node* p_gn);
+	void _graph_node_moved(Node *p_gn);
 
-    void _update_scroll();
-    void _scroll_moved(double);
-    void _input_event(const InputEvent& p_ev);
+	void _update_scroll();
+	void _scroll_moved(double);
+	void _input_event(const InputEvent& p_ev);
 
-    GraphEditFilter *top_layer;
-    void _top_layer_input(const InputEvent& p_ev);
-    void _top_layer_draw();
-    void _update_scroll_offset();
+	GraphEditFilter *top_layer;
+	void _top_layer_input(const InputEvent& p_ev);
+	void _top_layer_draw();
+	void _update_scroll_offset();
 
-    Array _get_connection_list() const;
+	Array _get_connection_list() const;
 
-friend class GraphEditFilter;
-    bool _filter_input(const Point2& p_point);
+	friend class GraphEditFilter;
+	bool _filter_input(const Point2& p_point);
 protected:
 
-    static void _bind_methods();
-    virtual void add_child_notify(Node *p_child);
-    virtual void remove_child_notify(Node *p_child);
-    void _notification(int p_what);
+	static void _bind_methods();
+	virtual void add_child_notify(Node *p_child);
+	virtual void remove_child_notify(Node *p_child);
+	void _notification(int p_what);
 
 public:
 
-    Error connect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
-    bool is_node_connected(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
-    void disconnect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
-    void clear_connections();
+	Error connect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
+	bool is_node_connected(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
+	void disconnect_node(const StringName& p_from, int p_from_port,const StringName& p_to,int p_to_port);
+	void clear_connections();
 
-    GraphEditFilter *get_top_layer() const { return top_layer; }
-    void get_connection_list(List<Connection> *r_connections) const;
+	GraphEditFilter *get_top_layer() const { return top_layer; }
+	void get_connection_list(List<Connection> *r_connections) const;
 
-    void set_right_disconnects(bool p_enable);
-    bool is_right_disconnects_enabled() const;
+	void set_right_disconnects(bool p_enable);
+	bool is_right_disconnects_enabled() const;
 
 
-    GraphEdit();
+	GraphEdit();
 };
 
 #endif // GRAPHEdit_H
diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp
index 760eb6ceede..f0917aa4d17 100644
--- a/scene/gui/graph_node.cpp
+++ b/scene/gui/graph_node.cpp
@@ -4,91 +4,91 @@
 
 bool GraphNode::_set(const StringName& p_name, const Variant& p_value) {
 
-    if (!p_name.operator String().begins_with("slot/"))
-        return false;
+	if (!p_name.operator String().begins_with("slot/"))
+		return false;
 
-    int idx=p_name.operator String().get_slice("/",1).to_int();
-    String what = p_name.operator String().get_slice("/",2);
+	int idx=p_name.operator String().get_slice("/",1).to_int();
+	String what = p_name.operator String().get_slice("/",2);
 
 
-    Slot si;
-    if (slot_info.has(idx))
-        si=slot_info[idx];
+	Slot si;
+	if (slot_info.has(idx))
+		si=slot_info[idx];
 
 
-    if (what=="left_enabled")
-        si.enable_left=p_value;
-    else if (what=="left_type")
-        si.type_left=p_value;
-    else if (what=="left_color")
-        si.color_left=p_value;
-    else if (what=="right_enabled")
-        si.enable_right=p_value;
-    else if (what=="right_type")
-        si.type_right=p_value;
-    else if (what=="right_color")
-        si.color_right=p_value;
-    else
-        return false;
+	if (what=="left_enabled")
+		si.enable_left=p_value;
+	else if (what=="left_type")
+		si.type_left=p_value;
+	else if (what=="left_color")
+		si.color_left=p_value;
+	else if (what=="right_enabled")
+		si.enable_right=p_value;
+	else if (what=="right_type")
+		si.type_right=p_value;
+	else if (what=="right_color")
+		si.color_right=p_value;
+	else
+		return false;
 
-    set_slot(idx,si.enable_left,si.type_left,si.color_left,si.enable_right,si.type_right,si.color_right);
-    update();
-    return true;
+	set_slot(idx,si.enable_left,si.type_left,si.color_left,si.enable_right,si.type_right,si.color_right);
+	update();
+	return true;
 }
 
 bool GraphNode::_get(const StringName& p_name,Variant &r_ret) const{
 
 
 
-    if (!p_name.operator String().begins_with("slot/")) {
-        return false;
-    }
+	if (!p_name.operator String().begins_with("slot/")) {
+		return false;
+	}
 
-    int idx=p_name.operator String().get_slice("/",1).to_int();
-    String what = p_name.operator String().get_slice("/",2);
+	int idx=p_name.operator String().get_slice("/",1).to_int();
+	String what = p_name.operator String().get_slice("/",2);
 
 
 
-    Slot si;
-    if (slot_info.has(idx))
-        si=slot_info[idx];
+	Slot si;
+	if (slot_info.has(idx))
+		si=slot_info[idx];
 
-    if (what=="left_enabled")
-        r_ret=si.enable_left;
-    else if (what=="left_type")
-        r_ret=si.type_left;
-    else if (what=="left_color")
-        r_ret=si.color_left;
-    else if (what=="right_enabled")
-        r_ret=si.enable_right;
-    else if (what=="right_type")
-        r_ret=si.type_right;
-    else if (what=="right_color")
-        r_ret=si.color_right;
-    else
-        return false;
+	if (what=="left_enabled")
+		r_ret=si.enable_left;
+	else if (what=="left_type")
+		r_ret=si.type_left;
+	else if (what=="left_color")
+		r_ret=si.color_left;
+	else if (what=="right_enabled")
+		r_ret=si.enable_right;
+	else if (what=="right_type")
+		r_ret=si.type_right;
+	else if (what=="right_color")
+		r_ret=si.color_right;
+	else
+		return false;
 
-    return true;
+	return true;
 }
 void GraphNode::_get_property_list( List<PropertyInfo> *p_list) const{
 
-    int idx=0;
-    for(int i=0;i<get_child_count();i++) {
-        Control *c=get_child(i)->cast_to<Control>();
-        if (!c || c->is_set_as_toplevel() )
-            continue;
+	int idx=0;
+	for(int i=0;i<get_child_count();i++) {
+		Control *c=get_child(i)->cast_to<Control>();
+		if (!c || c->is_set_as_toplevel() )
+			continue;
 
-        String base="slot/"+itos(idx)+"/";
+		String base="slot/"+itos(idx)+"/";
 
-        p_list->push_back(PropertyInfo(Variant::BOOL,base+"left_enabled"));
-        p_list->push_back(PropertyInfo(Variant::INT,base+"left_type"));
-        p_list->push_back(PropertyInfo(Variant::COLOR,base+"left_color"));
-        p_list->push_back(PropertyInfo(Variant::BOOL,base+"right_enabled"));
-        p_list->push_back(PropertyInfo(Variant::INT,base+"right_type"));
-        p_list->push_back(PropertyInfo(Variant::COLOR,base+"right_color"));
+		p_list->push_back(PropertyInfo(Variant::BOOL,base+"left_enabled"));
+		p_list->push_back(PropertyInfo(Variant::INT,base+"left_type"));
+		p_list->push_back(PropertyInfo(Variant::COLOR,base+"left_color"));
+		p_list->push_back(PropertyInfo(Variant::BOOL,base+"right_enabled"));
+		p_list->push_back(PropertyInfo(Variant::INT,base+"right_type"));
+		p_list->push_back(PropertyInfo(Variant::COLOR,base+"right_color"));
 
-        idx++;
-    }
+		idx++;
+	}
 }
 
 
@@ -96,61 +96,61 @@ void GraphNode::_resort() {
 
 
 
-    int sep=get_constant("separation");
-    Ref<StyleBox> sb=get_stylebox("frame");
-    bool first=true;
+	int sep=get_constant("separation");
+	Ref<StyleBox> sb=get_stylebox("frame");
+	bool first=true;
 
-    Size2 minsize;
+	Size2 minsize;
 
-    for(int i=0;i<get_child_count();i++) {
-        Control *c=get_child(i)->cast_to<Control>();
-        if (!c)
-            continue;
-        if (c->is_set_as_toplevel())
-            continue;
+	for(int i=0;i<get_child_count();i++) {
+		Control *c=get_child(i)->cast_to<Control>();
+		if (!c)
+			continue;
+		if (c->is_set_as_toplevel())
+			continue;
 
-        Size2i size=c->get_combined_minimum_size();
+		Size2i size=c->get_combined_minimum_size();
 
-        minsize.y+=size.y;
-        minsize.x=MAX(minsize.x,size.x);
+		minsize.y+=size.y;
+		minsize.x=MAX(minsize.x,size.x);
 
-        if (first)
-            first=false;
-        else
-            minsize.y+=sep;
+		if (first)
+			first=false;
+		else
+			minsize.y+=sep;
 
-    }
+	}
 
 
-    int vofs=0;
-    int w = get_size().x - sb->get_minimum_size().x;
+	int vofs=0;
+	int w = get_size().x - sb->get_minimum_size().x;
 
 
-    cache_y.clear();
-    for(int i=0;i<get_child_count();i++) {
-        Control *c=get_child(i)->cast_to<Control>();
-        if (!c)
-            continue;
-        if (c->is_set_as_toplevel())
-            continue;
+	cache_y.clear();
+	for(int i=0;i<get_child_count();i++) {
+		Control *c=get_child(i)->cast_to<Control>();
+		if (!c)
+			continue;
+		if (c->is_set_as_toplevel())
+			continue;
 
-        Size2i size=c->get_combined_minimum_size();
+		Size2i size=c->get_combined_minimum_size();
 
-        Rect2 r(sb->get_margin(MARGIN_LEFT),sb->get_margin(MARGIN_TOP)+vofs,w,size.y);
+		Rect2 r(sb->get_margin(MARGIN_LEFT),sb->get_margin(MARGIN_TOP)+vofs,w,size.y);
 
-        fit_child_in_rect(c,r);
-        cache_y.push_back(vofs+size.y*0.5);
+		fit_child_in_rect(c,r);
+		cache_y.push_back(vofs+size.y*0.5);
 
-        if (vofs>0)
-            vofs+=sep;
-        vofs+=size.y;
+		if (vofs>0)
+			vofs+=sep;
+		vofs+=size.y;
 
 
-    }
+	}
 
-    _change_notify();
-    update();
-    connpos_dirty=true;
+	_change_notify();
+	update();
+	connpos_dirty=true;
 
 
 }
@@ -158,124 +158,124 @@ void GraphNode::_resort() {
 
 void GraphNode::_notification(int p_what) {
 
-    if (p_what==NOTIFICATION_DRAW) {
+	if (p_what==NOTIFICATION_DRAW) {
 
-        Ref<StyleBox> sb=get_stylebox(selected ? "selectedframe" : "frame");
-        Ref<Texture> port =get_icon("port");
-        Ref<Texture> close =get_icon("close");
-        int close_offset = get_constant("close_offset");
-        Ref<Font> title_font = get_font("title_font");
-        int title_offset = get_constant("title_offset");
-        Color title_color = get_color("title_color");
-        Point2i icofs = -port->get_size()*0.5;
-        int edgeofs=get_constant("port_offset");
-        icofs.y+=sb->get_margin(MARGIN_TOP);
-        draw_style_box(sb,Rect2(Point2(),get_size()));
+		Ref<StyleBox> sb=get_stylebox(selected ? "selectedframe" : "frame");
+		Ref<Texture> port =get_icon("port");
+		Ref<Texture> close =get_icon("close");
+		int close_offset = get_constant("close_offset");
+		Ref<Font> title_font = get_font("title_font");
+		int title_offset = get_constant("title_offset");
+		Color title_color = get_color("title_color");
+		Point2i icofs = -port->get_size()*0.5;
+		int edgeofs=get_constant("port_offset");
+		icofs.y+=sb->get_margin(MARGIN_TOP);
+		draw_style_box(sb,Rect2(Point2(),get_size()));
 
-        int w = get_size().width-sb->get_minimum_size().x;
+		int w = get_size().width-sb->get_minimum_size().x;
 
-        if (show_close)
-            w-=close->get_width();
+		if (show_close)
+			w-=close->get_width();
 
-        draw_string(title_font,Point2(sb->get_margin(MARGIN_LEFT),-title_font->get_height()+title_font->get_ascent()+title_offset),title,title_color,w);
-        if (show_close) {
-            Vector2 cpos = Point2(w+sb->get_margin(MARGIN_LEFT),-close->get_height()+close_offset);
-            draw_texture(close,cpos);
-            close_rect.pos=cpos;
-            close_rect.size=close->get_size();
-        } else {
-            close_rect=Rect2();
-        }
+		draw_string(title_font,Point2(sb->get_margin(MARGIN_LEFT),-title_font->get_height()+title_font->get_ascent()+title_offset),title,title_color,w);
+		if (show_close) {
+			Vector2 cpos = Point2(w+sb->get_margin(MARGIN_LEFT),-close->get_height()+close_offset);
+			draw_texture(close,cpos);
+			close_rect.pos=cpos;
+			close_rect.size=close->get_size();
+		} else {
+			close_rect=Rect2();
+		}
 
-        for (Map<int,Slot>::Element *E=slot_info.front();E;E=E->next()) {
+		for (Map<int,Slot>::Element *E=slot_info.front();E;E=E->next()) {
 
-            if (E->key() < 0 || E->key()>=cache_y.size())
-                continue;
-            if (!slot_info.has(E->key()))
-                continue;
-            const Slot &s=slot_info[E->key()];
-            //left
-            if (s.enable_left)
-                port->draw(get_canvas_item(),icofs+Point2(edgeofs,cache_y[E->key()]),s.color_left);
-            if (s.enable_right)
-                port->draw(get_canvas_item(),icofs+Point2(get_size().x-edgeofs,cache_y[E->key()]),s.color_right);
+			if (E->key() < 0 || E->key()>=cache_y.size())
+				continue;
+			if (!slot_info.has(E->key()))
+				continue;
+			const Slot &s=slot_info[E->key()];
+			//left
+			if (s.enable_left)
+				port->draw(get_canvas_item(),icofs+Point2(edgeofs,cache_y[E->key()]),s.color_left);
+			if (s.enable_right)
+				port->draw(get_canvas_item(),icofs+Point2(get_size().x-edgeofs,cache_y[E->key()]),s.color_right);
 
-        }
-    }
+		}
+	}
 
-    if (p_what==NOTIFICATION_SORT_CHILDREN) {
+	if (p_what==NOTIFICATION_SORT_CHILDREN) {
 
-        _resort();
-    }
+		_resort();
+	}
 
 }
 
 
 void GraphNode::set_slot(int p_idx,bool p_enable_left,int p_type_left,const Color& p_color_left, bool p_enable_right,int p_type_right,const Color& p_color_right) {
 
-    ERR_FAIL_COND(p_idx<0);
+	ERR_FAIL_COND(p_idx<0);
 
-    if (!p_enable_left && p_type_left==0 && p_color_left==Color(1,1,1,1) && !p_enable_right && p_type_right==0 && p_color_right==Color(1,1,1,1)) {
-        slot_info.erase(p_idx);
-        return;
-    }
+	if (!p_enable_left && p_type_left==0 && p_color_left==Color(1,1,1,1) && !p_enable_right && p_type_right==0 && p_color_right==Color(1,1,1,1)) {
+		slot_info.erase(p_idx);
+		return;
+	}
 
-    Slot s;
-    s.enable_left=p_enable_left;
-    s.type_left=p_type_left;
-    s.color_left=p_color_left;
-    s.enable_right=p_enable_right;
-    s.type_right=p_type_right;
-    s.color_right=p_color_right;
-    slot_info[p_idx]=s;
-    update();
-    connpos_dirty=true;
+	Slot s;
+	s.enable_left=p_enable_left;
+	s.type_left=p_type_left;
+	s.color_left=p_color_left;
+	s.enable_right=p_enable_right;
+	s.type_right=p_type_right;
+	s.color_right=p_color_right;
+	slot_info[p_idx]=s;
+	update();
+	connpos_dirty=true;
 
 }
 
 void GraphNode::clear_slot(int p_idx){
 
-    slot_info.erase(p_idx);
-    update();
-    connpos_dirty=true;
+	slot_info.erase(p_idx);
+	update();
+	connpos_dirty=true;
 
 }
 void GraphNode::clear_all_slots(){
 
-    slot_info.clear();
-    update();
-    connpos_dirty=true;
+	slot_info.clear();
+	update();
+	connpos_dirty=true;
 
 }
 bool GraphNode::is_slot_enabled_left(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return false;
-    return slot_info[p_idx].enable_left;
+	if (!slot_info.has(p_idx))
+		return false;
+	return slot_info[p_idx].enable_left;
 
 }
 
 int GraphNode::get_slot_type_left(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return 0;
-    return slot_info[p_idx].type_left;
+	if (!slot_info.has(p_idx))
+		return 0;
+	return slot_info[p_idx].type_left;
 
 }
 
 Color GraphNode::get_slot_color_left(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return Color(1,1,1,1);
-    return slot_info[p_idx].color_left;
+	if (!slot_info.has(p_idx))
+		return Color(1,1,1,1);
+	return slot_info[p_idx].color_left;
 
 }
 
 bool GraphNode::is_slot_enabled_right(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return false;
-    return slot_info[p_idx].enable_right;
+	if (!slot_info.has(p_idx))
+		return false;
+	return slot_info[p_idx].enable_right;
 
 }
 
@@ -283,305 +283,305 @@ bool GraphNode::is_slot_enabled_right(int p_idx) const{
 
 int GraphNode::get_slot_type_right(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return 0;
-    return slot_info[p_idx].type_right;
+	if (!slot_info.has(p_idx))
+		return 0;
+	return slot_info[p_idx].type_right;
 
 }
 
 Color GraphNode::get_slot_color_right(int p_idx) const{
 
-    if (!slot_info.has(p_idx))
-        return Color(1,1,1,1);
-    return slot_info[p_idx].color_right;
+	if (!slot_info.has(p_idx))
+		return Color(1,1,1,1);
+	return slot_info[p_idx].color_right;
 
 }
 
 Size2 GraphNode::get_minimum_size() const {
 
-    Ref<Font> title_font = get_font("title_font");
+	Ref<Font> title_font = get_font("title_font");
 
-    int sep=get_constant("separation");
-    Ref<StyleBox> sb=get_stylebox("frame");
-    bool first=true;
+	int sep=get_constant("separation");
+	Ref<StyleBox> sb=get_stylebox("frame");
+	bool first=true;
 
-    Size2 minsize;
-    minsize.x=title_font->get_string_size(title).x;
-    if (show_close) {
-        Ref<Texture> close =get_icon("close");
-        minsize.x+=sep+close->get_width();
-    }
+	Size2 minsize;
+	minsize.x=title_font->get_string_size(title).x;
+	if (show_close) {
+		Ref<Texture> close =get_icon("close");
+		minsize.x+=sep+close->get_width();
+	}
 
 
-    for(int i=0;i<get_child_count();i++) {
+	for(int i=0;i<get_child_count();i++) {
 
-        Control *c=get_child(i)->cast_to<Control>();
-        if (!c)
-            continue;
-        if (c->is_set_as_toplevel())
-            continue;
+		Control *c=get_child(i)->cast_to<Control>();
+		if (!c)
+			continue;
+		if (c->is_set_as_toplevel())
+			continue;
 
-        Size2i size=c->get_combined_minimum_size();
+		Size2i size=c->get_combined_minimum_size();
 
-        minsize.y+=size.y;
-        minsize.x=MAX(minsize.x,size.x);
+		minsize.y+=size.y;
+		minsize.x=MAX(minsize.x,size.x);
 
-        if (first)
-            first=false;
-        else
-            minsize.y+=sep;
-    }
+		if (first)
+			first=false;
+		else
+			minsize.y+=sep;
+	}
 
-    return minsize+sb->get_minimum_size();
+	return minsize+sb->get_minimum_size();
 }
 
 void GraphNode::set_title(const String& p_title) {
 
-    title=p_title;
-    minimum_size_changed();
-    update();
+	title=p_title;
+	minimum_size_changed();
+	update();
 
 }
 
 String GraphNode::get_title() const{
 
-    return title;
+	return title;
 }
 
 void GraphNode::set_offset(const Vector2& p_offset) {
 
-    offset=p_offset;
-    emit_signal("offset_changed");
-    update();
+	offset=p_offset;
+	emit_signal("offset_changed");
+	update();
 }
 
 Vector2 GraphNode::get_offset() const {
 
-    return offset;
+	return offset;
 }
 
 void GraphNode::set_selected(bool p_selected)
 {
-    selected = p_selected;
-    update();
+	selected = p_selected;
+	update();
 }
 
 bool GraphNode::is_selected()
 {
-    return selected;
+	return selected;
 }
 
 void GraphNode::set_drag(bool p_drag)
 {
-    if (p_drag)
-        drag_from=get_offset();
-    else
-        emit_signal("dragged",drag_from,get_offset()); //useful for undo/redo
+	if (p_drag)
+		drag_from=get_offset();
+	else
+		emit_signal("dragged",drag_from,get_offset()); //useful for undo/redo
 }
 
 Vector2 GraphNode::get_drag_from()
 {
-    return drag_from;
+	return drag_from;
 }
 
 
 void GraphNode::set_show_close_button(bool p_enable){
 
-    show_close=p_enable;
-    update();
+	show_close=p_enable;
+	update();
 }
 bool GraphNode::is_close_button_visible() const{
 
-    return show_close;
+	return show_close;
 }
 
 void GraphNode::_connpos_update() {
 
 
-    int edgeofs=get_constant("port_offset");
-    int sep=get_constant("separation");
+	int edgeofs=get_constant("port_offset");
+	int sep=get_constant("separation");
 
-    Ref<StyleBox> sb=get_stylebox("frame");
-    conn_input_cache.clear();
-    conn_output_cache.clear();
-    int vofs=0;
+	Ref<StyleBox> sb=get_stylebox("frame");
+	conn_input_cache.clear();
+	conn_output_cache.clear();
+	int vofs=0;
 
-    int idx=0;
+	int idx=0;
 
-    for(int i=0;i<get_child_count();i++) {
-        Control *c=get_child(i)->cast_to<Control>();
-        if (!c)
-            continue;
-        if (c->is_set_as_toplevel())
-            continue;
+	for(int i=0;i<get_child_count();i++) {
+		Control *c=get_child(i)->cast_to<Control>();
+		if (!c)
+			continue;
+		if (c->is_set_as_toplevel())
+			continue;
 
-        Size2i size=c->get_combined_minimum_size();
+		Size2i size=c->get_combined_minimum_size();
 
-        int y = sb->get_margin(MARGIN_TOP)+vofs;
-        int h = size.y;
+		int y = sb->get_margin(MARGIN_TOP)+vofs;
+		int h = size.y;
 
 
-        if (slot_info.has(idx)) {
+		if (slot_info.has(idx)) {
 
-            if (slot_info[idx].enable_left) {
-                ConnCache cc;
-                cc.pos=Point2i(edgeofs,y+h/2);
-                cc.type=slot_info[idx].type_left;
-                cc.color=slot_info[idx].color_left;
-                conn_input_cache.push_back(cc);
-            }
-            if (slot_info[idx].enable_right) {
-                ConnCache cc;
-                cc.pos=Point2i(get_size().width-edgeofs,y+h/2);
-                cc.type=slot_info[idx].type_right;
-                cc.color=slot_info[idx].color_right;
-                conn_output_cache.push_back(cc);
-            }
-        }
+			if (slot_info[idx].enable_left) {
+				ConnCache cc;
+				cc.pos=Point2i(edgeofs,y+h/2);
+				cc.type=slot_info[idx].type_left;
+				cc.color=slot_info[idx].color_left;
+				conn_input_cache.push_back(cc);
+			}
+			if (slot_info[idx].enable_right) {
+				ConnCache cc;
+				cc.pos=Point2i(get_size().width-edgeofs,y+h/2);
+				cc.type=slot_info[idx].type_right;
+				cc.color=slot_info[idx].color_right;
+				conn_output_cache.push_back(cc);
+			}
+		}
 
-        if (vofs>0)
-            vofs+=sep;
-        vofs+=size.y;
-        idx++;
+		if (vofs>0)
+			vofs+=sep;
+		vofs+=size.y;
+		idx++;
 
-    }
+	}
 
 
-    connpos_dirty=false;
+	connpos_dirty=false;
 }
 
 int GraphNode::get_connection_input_count()  {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    return conn_input_cache.size();
+	return conn_input_cache.size();
 
 }
 int GraphNode::get_connection_output_count() {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    return conn_output_cache.size();
+	return conn_output_cache.size();
 
 }
 
 
 Vector2 GraphNode::get_connection_input_pos(int p_idx) {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),Vector2());
-    return conn_input_cache[p_idx].pos;
+	ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),Vector2());
+	return conn_input_cache[p_idx].pos;
 }
 
 int GraphNode::get_connection_input_type(int p_idx) {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),0);
-    return conn_input_cache[p_idx].type;
+	ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),0);
+	return conn_input_cache[p_idx].type;
 }
 
 Color GraphNode::get_connection_input_color(int p_idx) {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),Color());
-    return conn_input_cache[p_idx].color;
+	ERR_FAIL_INDEX_V(p_idx,conn_input_cache.size(),Color());
+	return conn_input_cache[p_idx].color;
 }
 
 Vector2 GraphNode::get_connection_output_pos(int p_idx){
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),Vector2());
-    return conn_output_cache[p_idx].pos;
+	ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),Vector2());
+	return conn_output_cache[p_idx].pos;
 
 }
 
 int GraphNode::get_connection_output_type(int p_idx) {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),0);
-    return conn_output_cache[p_idx].type;
+	ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),0);
+	return conn_output_cache[p_idx].type;
 }
 
 Color GraphNode::get_connection_output_color(int p_idx) {
 
-    if (connpos_dirty)
-        _connpos_update();
+	if (connpos_dirty)
+		_connpos_update();
 
-    ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),Color());
-    return conn_output_cache[p_idx].color;
+	ERR_FAIL_INDEX_V(p_idx,conn_output_cache.size(),Color());
+	return conn_output_cache[p_idx].color;
 }
 
 void GraphNode::_input_event(const InputEvent& p_ev) {
 
-    if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.pressed && p_ev.mouse_button.button_index==BUTTON_LEFT) {
+	if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.pressed && p_ev.mouse_button.button_index==BUTTON_LEFT) {
 
-        Vector2 mpos = Vector2(p_ev.mouse_button.x,p_ev.mouse_button.y);
-        if (close_rect.size!=Size2() && close_rect.has_point(mpos)) {
-            emit_signal("close_request");
-            return;
-        }
-        emit_signal("raise_request");
+		Vector2 mpos = Vector2(p_ev.mouse_button.x,p_ev.mouse_button.y);
+		if (close_rect.size!=Size2() && close_rect.has_point(mpos)) {
+			emit_signal("close_request");
+			return;
+		}
+		emit_signal("raise_request");
 
-    }
+	}
 
 }
 
 
 void GraphNode::_bind_methods() {
 
-    ObjectTypeDB::bind_method(_MD("set_title","title"),&GraphNode::set_title);
-    ObjectTypeDB::bind_method(_MD("get_title"),&GraphNode::get_title);
-    ObjectTypeDB::bind_method(_MD("_input_event"),&GraphNode::_input_event);
+	ObjectTypeDB::bind_method(_MD("set_title","title"),&GraphNode::set_title);
+	ObjectTypeDB::bind_method(_MD("get_title"),&GraphNode::get_title);
+	ObjectTypeDB::bind_method(_MD("_input_event"),&GraphNode::_input_event);
 
-    ObjectTypeDB::bind_method(_MD("set_slot","idx","enable_left","type_left","color_left","enable_right","type_right","color_right"),&GraphNode::set_slot);
-    ObjectTypeDB::bind_method(_MD("clear_slot","idx"),&GraphNode::clear_slot);
-    ObjectTypeDB::bind_method(_MD("clear_all_slots","idx"),&GraphNode::clear_all_slots);
-    ObjectTypeDB::bind_method(_MD("is_slot_enabled_left","idx"),&GraphNode::is_slot_enabled_left);
-    ObjectTypeDB::bind_method(_MD("get_slot_type_left","idx"),&GraphNode::get_slot_type_left);
-    ObjectTypeDB::bind_method(_MD("get_slot_color_left","idx"),&GraphNode::get_slot_color_left);
-    ObjectTypeDB::bind_method(_MD("is_slot_enabled_right","idx"),&GraphNode::is_slot_enabled_right);
-    ObjectTypeDB::bind_method(_MD("get_slot_type_right","idx"),&GraphNode::get_slot_type_right);
-    ObjectTypeDB::bind_method(_MD("get_slot_color_right","idx"),&GraphNode::get_slot_color_right);
+	ObjectTypeDB::bind_method(_MD("set_slot","idx","enable_left","type_left","color_left","enable_right","type_right","color_right"),&GraphNode::set_slot);
+	ObjectTypeDB::bind_method(_MD("clear_slot","idx"),&GraphNode::clear_slot);
+	ObjectTypeDB::bind_method(_MD("clear_all_slots","idx"),&GraphNode::clear_all_slots);
+	ObjectTypeDB::bind_method(_MD("is_slot_enabled_left","idx"),&GraphNode::is_slot_enabled_left);
+	ObjectTypeDB::bind_method(_MD("get_slot_type_left","idx"),&GraphNode::get_slot_type_left);
+	ObjectTypeDB::bind_method(_MD("get_slot_color_left","idx"),&GraphNode::get_slot_color_left);
+	ObjectTypeDB::bind_method(_MD("is_slot_enabled_right","idx"),&GraphNode::is_slot_enabled_right);
+	ObjectTypeDB::bind_method(_MD("get_slot_type_right","idx"),&GraphNode::get_slot_type_right);
+	ObjectTypeDB::bind_method(_MD("get_slot_color_right","idx"),&GraphNode::get_slot_color_right);
 
-    ObjectTypeDB::bind_method(_MD("set_offset","offset"),&GraphNode::set_offset);
-    ObjectTypeDB::bind_method(_MD("get_offset"),&GraphNode::get_offset);
+	ObjectTypeDB::bind_method(_MD("set_offset","offset"),&GraphNode::set_offset);
+	ObjectTypeDB::bind_method(_MD("get_offset"),&GraphNode::get_offset);
 
-    ObjectTypeDB::bind_method(_MD("get_connection_output_count"),&GraphNode::get_connection_output_count);
-    ObjectTypeDB::bind_method(_MD("get_connection_input_count"),&GraphNode::get_connection_input_count);
+	ObjectTypeDB::bind_method(_MD("get_connection_output_count"),&GraphNode::get_connection_output_count);
+	ObjectTypeDB::bind_method(_MD("get_connection_input_count"),&GraphNode::get_connection_input_count);
 
-    ObjectTypeDB::bind_method(_MD("get_connection_output_pos","idx"),&GraphNode::get_connection_output_pos);
-    ObjectTypeDB::bind_method(_MD("get_connection_output_type","idx"),&GraphNode::get_connection_output_type);
-    ObjectTypeDB::bind_method(_MD("get_connection_output_color","idx"),&GraphNode::get_connection_output_color);
-    ObjectTypeDB::bind_method(_MD("get_connection_input_pos","idx"),&GraphNode::get_connection_input_pos);
-    ObjectTypeDB::bind_method(_MD("get_connection_input_type","idx"),&GraphNode::get_connection_input_type);
-    ObjectTypeDB::bind_method(_MD("get_connection_input_color","idx"),&GraphNode::get_connection_input_color);
+	ObjectTypeDB::bind_method(_MD("get_connection_output_pos","idx"),&GraphNode::get_connection_output_pos);
+	ObjectTypeDB::bind_method(_MD("get_connection_output_type","idx"),&GraphNode::get_connection_output_type);
+	ObjectTypeDB::bind_method(_MD("get_connection_output_color","idx"),&GraphNode::get_connection_output_color);
+	ObjectTypeDB::bind_method(_MD("get_connection_input_pos","idx"),&GraphNode::get_connection_input_pos);
+	ObjectTypeDB::bind_method(_MD("get_connection_input_type","idx"),&GraphNode::get_connection_input_type);
+	ObjectTypeDB::bind_method(_MD("get_connection_input_color","idx"),&GraphNode::get_connection_input_color);
 
 
-    ObjectTypeDB::bind_method(_MD("set_show_close_button","show"),&GraphNode::set_show_close_button);
-    ObjectTypeDB::bind_method(_MD("is_close_button_visible"),&GraphNode::is_close_button_visible);
+	ObjectTypeDB::bind_method(_MD("set_show_close_button","show"),&GraphNode::set_show_close_button);
+	ObjectTypeDB::bind_method(_MD("is_close_button_visible"),&GraphNode::is_close_button_visible);
 
-    ADD_PROPERTY( PropertyInfo(Variant::STRING,"title"),_SCS("set_title"),_SCS("get_title"));
-    ADD_PROPERTY( PropertyInfo(Variant::BOOL,"show_close"),_SCS("set_show_close_button"),_SCS("is_close_button_visible"));
+	ADD_PROPERTY( PropertyInfo(Variant::STRING,"title"),_SCS("set_title"),_SCS("get_title"));
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"show_close"),_SCS("set_show_close_button"),_SCS("is_close_button_visible"));
 
-    ADD_SIGNAL(MethodInfo("offset_changed"));
-    ADD_SIGNAL(MethodInfo("dragged",PropertyInfo(Variant::VECTOR2,"from"),PropertyInfo(Variant::VECTOR2,"to")));
-    ADD_SIGNAL(MethodInfo("raise_request"));
-    ADD_SIGNAL(MethodInfo("close_request"));
+	ADD_SIGNAL(MethodInfo("offset_changed"));
+	ADD_SIGNAL(MethodInfo("dragged",PropertyInfo(Variant::VECTOR2,"from"),PropertyInfo(Variant::VECTOR2,"to")));
+	ADD_SIGNAL(MethodInfo("raise_request"));
+	ADD_SIGNAL(MethodInfo("close_request"));
 }
 
 GraphNode::GraphNode() {
-    show_close=false;
-    connpos_dirty=true;
+	show_close=false;
+	connpos_dirty=true;
 }
diff --git a/scene/gui/graph_node.h b/scene/gui/graph_node.h
index 6bece22ac58..201529380dd 100644
--- a/scene/gui/graph_node.h
+++ b/scene/gui/graph_node.h
@@ -5,101 +5,101 @@
 
 class GraphNode : public Container {
 
-    OBJ_TYPE(GraphNode,Container);
+	OBJ_TYPE(GraphNode,Container);
 
 
 
-    struct Slot {
-        bool enable_left;
-        int type_left;
-        Color color_left;
-        bool enable_right;
-        int type_right;
-        Color color_right;
+	struct Slot {
+		bool enable_left;
+		int type_left;
+		Color color_left;
+		bool enable_right;
+		int type_right;
+		Color color_right;
 
 
-        Slot() { enable_left=false; type_left=0; color_left=Color(1,1,1,1); enable_right=false; type_right=0; color_right=Color(1,1,1,1); }
-    };
+		Slot() { enable_left=false; type_left=0; color_left=Color(1,1,1,1); enable_right=false; type_right=0; color_right=Color(1,1,1,1); }
+	};
 
-    String title;
-    bool show_close;
-    Vector2 offset;
+	String title;
+	bool show_close;
+	Vector2 offset;
 
-    Rect2 close_rect;
+	Rect2 close_rect;
 
-    Vector<int> cache_y;
+	Vector<int> cache_y;
 
-    struct ConnCache {
-        Vector2 pos;
-        int type;
-        Color color;
-    };
+	struct ConnCache {
+		Vector2 pos;
+		int type;
+		Color color;
+	};
 
-    Vector<ConnCache> conn_input_cache;
-    Vector<ConnCache> conn_output_cache;
+	Vector<ConnCache> conn_input_cache;
+	Vector<ConnCache> conn_output_cache;
 
-    Map<int,Slot> slot_info;
+	Map<int,Slot> slot_info;
 
-    bool connpos_dirty;
+	bool connpos_dirty;
 
-    void _connpos_update();
-    void _resort();
+	void _connpos_update();
+	void _resort();
 
-    Vector2 drag_from;
-    bool selected;
+	Vector2 drag_from;
+	bool selected;
 protected:
 
-    void _input_event(const InputEvent& p_ev);
-    void _notification(int p_what);
-    static void _bind_methods();
+	void _input_event(const InputEvent& p_ev);
+	void _notification(int p_what);
+	static void _bind_methods();
 
-    bool _set(const StringName& p_name, const Variant& p_value);
-    bool _get(const StringName& p_name,Variant &r_ret) const;
-    void _get_property_list( List<PropertyInfo> *p_list) const;
+	bool _set(const StringName& p_name, const Variant& p_value);
+	bool _get(const StringName& p_name,Variant &r_ret) const;
+	void _get_property_list( List<PropertyInfo> *p_list) const;
 
 public:
 
 
 
 
-    void set_slot(int p_idx,bool p_enable_left,int p_type_left,const Color& p_color_left, bool p_enable_right,int p_type_right,const Color& p_color_right);
-    void clear_slot(int p_idx);
-    void clear_all_slots();
-    bool is_slot_enabled_left(int p_idx) const;
-    int get_slot_type_left(int p_idx) const;
-    Color get_slot_color_left(int p_idx) const;
-    bool is_slot_enabled_right(int p_idx) const;
-    int get_slot_type_right(int p_idx) const;
-    Color get_slot_color_right(int p_idx) const;
+	void set_slot(int p_idx,bool p_enable_left,int p_type_left,const Color& p_color_left, bool p_enable_right,int p_type_right,const Color& p_color_right);
+	void clear_slot(int p_idx);
+	void clear_all_slots();
+	bool is_slot_enabled_left(int p_idx) const;
+	int get_slot_type_left(int p_idx) const;
+	Color get_slot_color_left(int p_idx) const;
+	bool is_slot_enabled_right(int p_idx) const;
+	int get_slot_type_right(int p_idx) const;
+	Color get_slot_color_right(int p_idx) const;
 
-    void set_title(const String& p_title);
-    String get_title() const;
+	void set_title(const String& p_title);
+	String get_title() const;
 
-    void set_offset(const Vector2& p_offset);
-    Vector2 get_offset() const;
+	void set_offset(const Vector2& p_offset);
+	Vector2 get_offset() const;
 
-    void set_selected(bool p_selected);
-    bool is_selected();
+	void set_selected(bool p_selected);
+	bool is_selected();
 
-    void set_drag(bool p_drag);
-    Vector2 get_drag_from();
+	void set_drag(bool p_drag);
+	Vector2 get_drag_from();
 
-    void set_show_close_button(bool p_enable);
-    bool is_close_button_visible() const;
+	void set_show_close_button(bool p_enable);
+	bool is_close_button_visible() const;
 
-    int get_connection_input_count() ;
-    int get_connection_output_count() ;
-    Vector2 get_connection_input_pos(int p_idx);
-    int get_connection_input_type(int p_idx);
-    Color get_connection_input_color(int p_idx);
-    Vector2 get_connection_output_pos(int p_idx);
-    int get_connection_output_type(int p_idx);
-    Color get_connection_output_color(int p_idx);
+	int get_connection_input_count() ;
+	int get_connection_output_count() ;
+	Vector2 get_connection_input_pos(int p_idx);
+	int get_connection_input_type(int p_idx);
+	Color get_connection_input_color(int p_idx);
+	Vector2 get_connection_output_pos(int p_idx);
+	int get_connection_output_type(int p_idx);
+	Color get_connection_output_color(int p_idx);
 
 
-    virtual Size2 get_minimum_size() const;
+	virtual Size2 get_minimum_size() const;
 
-    GraphNode();
+	GraphNode();
 };
 
 
diff --git a/scene/resources/default_theme/default_theme.cpp b/scene/resources/default_theme/default_theme.cpp
index 667dfd46328..58ba5fba254 100644
--- a/scene/resources/default_theme/default_theme.cpp
+++ b/scene/resources/default_theme/default_theme.cpp
@@ -31,7 +31,7 @@ static  TexCacheMap *tex_cache;
 
 template<class T>
 static Ref<StyleBoxTexture> make_stylebox(T p_src,float p_left, float p_top, float p_right, float p_botton,float p_margin_left=-1, float p_margin_top=-1, float p_margin_right=-1, float p_margin_botton=-1, bool p_draw_center=true) {
-	
+
 	Ref<ImageTexture> texture;
 
 
@@ -56,17 +56,17 @@ static Ref<StyleBoxTexture> make_stylebox(T p_src,float p_left, float p_top, flo
 	style->set_default_margin( MARGIN_BOTTOM, p_margin_botton );
 	style->set_default_margin( MARGIN_TOP, p_margin_top );
 	style->set_draw_center(p_draw_center);
-	
+
 	return style;
 }
 
 template<class T>
 static Ref<Texture> make_icon(T p_src) {
-	
-	
+
+
 	Ref<ImageTexture> texture( memnew( ImageTexture ) );
 	texture->create_from_image( Image(p_src),ImageTexture::FLAG_FILTER );
-		
+
 	return texture;
 }
 
@@ -75,7 +75,7 @@ static Ref<Font> make_font(int p_height,int p_ascent, int p_valign, int p_charco
 
 	Ref<Font> font( memnew( Font ) );
 	font->add_texture( p_texture );
-	
+
 	for (int i=0;i<p_charcount;i++) {
 
 		const int *c = &p_chars[i*8];
@@ -91,9 +91,9 @@ static Ref<Font> make_font(int p_height,int p_ascent, int p_valign, int p_charco
 
 
 		font->add_char( chr, 0, frect, align,advance );
-		
+
 	}
-	
+
 	font->set_height( p_height );
 	font->set_ascent( p_ascent );
 
@@ -152,12 +152,12 @@ static Ref<Font> make_font2(int p_height,int p_ascent, int p_charcount, const in
 static Ref<StyleBox> make_empty_stylebox(float p_margin_left=-1, float p_margin_top=-1, float p_margin_right=-1, float p_margin_botton=-1) {
 
 	Ref<StyleBox> style( memnew( StyleBoxEmpty) );
-	
+
 	style->set_default_margin( MARGIN_LEFT, p_margin_left );
 	style->set_default_margin( MARGIN_RIGHT, p_margin_right );
 	style->set_default_margin( MARGIN_BOTTOM, p_margin_botton );
 	style->set_default_margin( MARGIN_TOP, p_margin_top );
-	
+
 	return style;
 }
 
@@ -300,49 +300,49 @@ void make_default_theme() {
 
 	t->set_constant("hseparation","MenuButton", 0 );
 
-    // CheckBox
+	// CheckBox
 
-    Ref<StyleBox> cbx_empty = memnew( StyleBoxEmpty );
-    cbx_empty->set_default_margin(MARGIN_LEFT,22);
-    cbx_empty->set_default_margin(MARGIN_RIGHT,4);
-    cbx_empty->set_default_margin(MARGIN_TOP,4);
-    cbx_empty->set_default_margin(MARGIN_BOTTOM,5);
-    Ref<StyleBox> cbx_focus = focus;
-    cbx_focus->set_default_margin(MARGIN_LEFT,4);
-    cbx_focus->set_default_margin(MARGIN_RIGHT,22);
-    cbx_focus->set_default_margin(MARGIN_TOP,4);
-    cbx_focus->set_default_margin(MARGIN_BOTTOM,5);
+	Ref<StyleBox> cbx_empty = memnew( StyleBoxEmpty );
+	cbx_empty->set_default_margin(MARGIN_LEFT,22);
+	cbx_empty->set_default_margin(MARGIN_RIGHT,4);
+	cbx_empty->set_default_margin(MARGIN_TOP,4);
+	cbx_empty->set_default_margin(MARGIN_BOTTOM,5);
+	Ref<StyleBox> cbx_focus = focus;
+	cbx_focus->set_default_margin(MARGIN_LEFT,4);
+	cbx_focus->set_default_margin(MARGIN_RIGHT,22);
+	cbx_focus->set_default_margin(MARGIN_TOP,4);
+	cbx_focus->set_default_margin(MARGIN_BOTTOM,5);
 
-    t->set_stylebox("normal","CheckBox", cbx_empty );
-    t->set_stylebox("pressed","CheckBox", cbx_empty );
-    t->set_stylebox("disabled","CheckBox", cbx_empty );
-    t->set_stylebox("hover","CheckBox", cbx_empty );
-    t->set_stylebox("focus","CheckBox", cbx_focus );
+	t->set_stylebox("normal","CheckBox", cbx_empty );
+	t->set_stylebox("pressed","CheckBox", cbx_empty );
+	t->set_stylebox("disabled","CheckBox", cbx_empty );
+	t->set_stylebox("hover","CheckBox", cbx_empty );
+	t->set_stylebox("focus","CheckBox", cbx_focus );
 
-    t->set_icon("checked", "CheckBox", make_icon(checked_png));
-    t->set_icon("unchecked", "CheckBox", make_icon(unchecked_png));
-    t->set_icon("radio_checked", "CheckBox", make_icon(radio_checked_png));
-    t->set_icon("radio_unchecked", "CheckBox", make_icon(radio_unchecked_png));
+	t->set_icon("checked", "CheckBox", make_icon(checked_png));
+	t->set_icon("unchecked", "CheckBox", make_icon(unchecked_png));
+	t->set_icon("radio_checked", "CheckBox", make_icon(radio_checked_png));
+	t->set_icon("radio_unchecked", "CheckBox", make_icon(radio_unchecked_png));
 
-    t->set_font("font","CheckBox", default_font );
+	t->set_font("font","CheckBox", default_font );
 
-    t->set_color("font_color","CheckBox", control_font_color );
-    t->set_color("font_color_pressed","CheckBox", control_font_color_pressed );
-    t->set_color("font_color_hover","CheckBox", control_font_color_hover );
-    t->set_color("font_color_disabled","CheckBox", control_font_color_disabled );
+	t->set_color("font_color","CheckBox", control_font_color );
+	t->set_color("font_color_pressed","CheckBox", control_font_color_pressed );
+	t->set_color("font_color_hover","CheckBox", control_font_color_hover );
+	t->set_color("font_color_disabled","CheckBox", control_font_color_disabled );
 
-    t->set_constant("hseparation","CheckBox",4);
-    t->set_constant("check_vadjust","CheckBox",0);
+	t->set_constant("hseparation","CheckBox",4);
+	t->set_constant("check_vadjust","CheckBox",0);
 
 
 
 	// CheckButton
-	
+
 	Ref<StyleBox> cb_empty = memnew( StyleBoxEmpty );
 	cb_empty->set_default_margin(MARGIN_LEFT,6);
 	cb_empty->set_default_margin(MARGIN_RIGHT,70);
 	cb_empty->set_default_margin(MARGIN_TOP,4);
-    cb_empty->set_default_margin(MARGIN_BOTTOM,4);
+	cb_empty->set_default_margin(MARGIN_BOTTOM,4);
 
 	t->set_stylebox("normal","CheckButton", cb_empty );
 	t->set_stylebox("pressed","CheckButton", cb_empty );
@@ -366,7 +366,7 @@ void make_default_theme() {
 
 
 	// Label
-	            
+
 	t->set_font("font","Label", default_font );
 
 	t->set_color("font_color","Label", Color(1,1,1) );
@@ -558,11 +558,11 @@ void make_default_theme() {
 	// GraphNode
 
 	Ref<StyleBoxTexture> graphsb = make_stylebox(graph_node_png,6,24,6,5,16,24,16,5);
-    Ref<StyleBoxTexture> graphsbselected = make_stylebox(graph_node_selected_png,6,24,6,5,16,24,16,5);
+	Ref<StyleBoxTexture> graphsbselected = make_stylebox(graph_node_selected_png,6,24,6,5,16,24,16,5);
 	//graphsb->set_expand_margin_size(MARGIN_LEFT,10);
 	//graphsb->set_expand_margin_size(MARGIN_RIGHT,10);
 	t->set_stylebox("frame","GraphNode", graphsb );
-    t->set_stylebox("selectedframe","GraphNode", graphsbselected );
+	t->set_stylebox("selectedframe","GraphNode", graphsbselected );
 	t->set_constant("separation","GraphNode", 1 );
 	t->set_icon("port","GraphNode", make_icon( graph_port_png ) );
 	t->set_icon("close","GraphNode", make_icon( graph_node_close_png ) );
@@ -713,7 +713,7 @@ void make_default_theme() {
 
 
 	// FileDialog
-	
+
 	t->set_icon("folder","FileDialog",make_icon(icon_folder_png));
 	t->set_color("files_disabled","FileDialog",Color(0,0,0,0.7));
 
@@ -877,10 +877,10 @@ void make_default_theme() {
 
 #endif
 void clear_default_theme() {
-	
+
 	Theme::set_default( Ref<Theme>() );
 	Theme::set_default_icon( Ref< Texture >() );
-	Theme::set_default_style( Ref< StyleBox >() );	
+	Theme::set_default_style( Ref< StyleBox >() );
 	Theme::set_default_font( Ref< Font >() );
 
 }
diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp
index a0f7edbd933..6e95432b99f 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) {
+	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();
-        }
+		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::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) {
+		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;
-                }
+			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);
+		float ofs = CLAMP(x/float(total_w),0,1);
 
-                grabbed=-1;
-                grabbing=true;
-                int pos=-1;
-                for(int i=0;i<points.size();i++) {
+		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;
+	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;
+	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;
-        }
+	/* 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][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);
+	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;
+	/* 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;
+	/* 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 */
+	/* 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 },
-        };
+	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++)
+		{
+			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]);
-                }
-                }
+	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 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];
+	/* 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);
+	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);
-        }
+	/*	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;
+	/* 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;
+		/* increment the y values */
+		y += dy;
+		dy += dy2;
+		dy2 += dy3;
 
-                newx = CLAMP ((Math::round (x)), 0, xmax);
-                newy = CLAMP ((Math::round (y)), 0, ymax);
+		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 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(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(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;
-                }
-        }
+	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;
+	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();
+		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("_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("_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("_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 ea21a7706fb..5f93b9df7d1 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);
+	OBJ_TYPE(ShaderGraphView,Node);
 
 
 
-    CustomPropertyEditor *ped_popup;
-    bool block_update;
+	CustomPropertyEditor *ped_popup;
+	bool block_update;
 
-    Label *status;
-    GraphEdit *graph_edit;
-    Ref<ShaderGraph> graph;
-    int edited_id;
+	Label *status;
+	GraphEdit *graph_edit;
+	Ref<ShaderGraph> graph;
+	int edited_id;
 
-    ShaderGraph::ShaderType type;
+	ShaderGraph::ShaderType type;
 
-    void _update_graph();
-    void _create_node(int p_id);
+	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 _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 _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;
+	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