Merge branch 'master' of https://github.com/not-surt/godot into snapping2

Conflicts:
	tools/editor/plugins/canvas_item_editor_plugin.cpp
	tools/editor/plugins/canvas_item_editor_plugin.h

tools/editor/plugins/baked_light_baker.cpp

@@ -1233,7 +1233,7 @@ float BakedLightBaker::_throw_ray(ThreadStack& thread_stack,bool p_bake_direct,c
 			if (dist<r) {
 				//avoid accumulaiton of light on corners
 				//plot_light=plot_light.linear_interpolate(Color(0,0,0,0),1.0-sd/plot_size*plot_size);
-				skip-true;
+				skip=true;
 
 			} else {
 

tools/editor/plugins/collision_polygon_2d_editor_plugin.cpp

@@ -4,6 +4,7 @@
 #include "os/file_access.h"
 #include "tools/editor/editor_settings.h"
 
+
 void CollisionPolygon2DEditor::_notification(int p_what) {
 
 	switch(p_what) {
@@ -357,6 +358,7 @@ void CollisionPolygon2DEditor::edit(Node *p_collision_polygon) {
 		wip.clear();
 		wip_active=false;
 		edited_point=-1;
+		canvas_item_editor->get_viewport_control()->update();
 
 	} else {
 		node=NULL;

tools/editor/plugins/light_occluder_2d_editor_plugin.cpp

@@ -0,0 +1,502 @@
+#include "light_occluder_2d_editor_plugin.h"
+
+#include "canvas_item_editor_plugin.h"
+#include "os/file_access.h"
+#include "tools/editor/editor_settings.h"
+
+void LightOccluder2DEditor::_notification(int p_what) {
+
+	switch(p_what) {
+
+		case NOTIFICATION_READY: {
+
+			button_create->set_icon( get_icon("Edit","EditorIcons"));
+			button_edit->set_icon( get_icon("MovePoint","EditorIcons"));
+			button_edit->set_pressed(true);
+			get_tree()->connect("node_removed",this,"_node_removed");
+			create_poly->connect("confirmed",this,"_create_poly");
+
+		} break;
+		case NOTIFICATION_FIXED_PROCESS: {
+
+
+		} break;
+	}
+
+}
+void LightOccluder2DEditor::_node_removed(Node *p_node) {
+
+	if(p_node==node) {
+		node=NULL;
+		hide();
+		canvas_item_editor->get_viewport_control()->update();
+	}
+
+}
+
+
+Vector2 LightOccluder2DEditor::snap_point(const Vector2& p_point) const {
+
+	if (canvas_item_editor->is_snap_active()) {
+
+		return p_point.snapped(Vector2(1,1)*canvas_item_editor->get_snap());
+
+	} else {
+		return p_point;
+	}
+}
+
+void LightOccluder2DEditor::_menu_option(int p_option) {
+
+	switch(p_option) {
+
+		case MODE_CREATE: {
+
+			mode=MODE_CREATE;
+			button_create->set_pressed(true);
+			button_edit->set_pressed(false);
+		} break;
+		case MODE_EDIT: {
+
+			mode=MODE_EDIT;
+			button_create->set_pressed(false);
+			button_edit->set_pressed(true);
+		} break;
+
+	}
+}
+
+void LightOccluder2DEditor::_wip_close(bool p_closed) {
+
+	undo_redo->create_action("Create Poly");
+	undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",node->get_occluder_polygon()->get_polygon());
+	undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",wip);
+	undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_closed",node->get_occluder_polygon()->is_closed());
+	undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_closed",p_closed);
+
+	undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+	undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+	undo_redo->commit_action();
+	wip.clear();
+	wip_active=false;
+	mode=MODE_EDIT;
+	button_edit->set_pressed(true);
+	button_create->set_pressed(false);
+	edited_point=-1;
+}
+
+bool LightOccluder2DEditor::forward_input_event(const InputEvent& p_event) {
+
+
+	if (!node)
+		return false;
+
+	if (node->get_occluder_polygon().is_null()) {
+		if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+			create_poly->set_text("No OccluderPolygon2D resource on this node.\nCreate and assign one?");
+			create_poly->popup_centered_minsize();
+		}
+		return (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1);
+	}
+	switch(p_event.type) {
+
+		case InputEvent::MOUSE_BUTTON: {
+
+			const InputEventMouseButton &mb=p_event.mouse_button;
+
+			Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
+
+
+			Vector2 gpoint = Point2(mb.x,mb.y);
+			Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
+			cpoint=snap_point(cpoint);
+			cpoint = node->get_global_transform().affine_inverse().xform(cpoint);
+
+			Vector<Vector2> poly = Variant(node->get_occluder_polygon()->get_polygon());
+
+			//first check if a point is to be added (segment split)
+			real_t grab_treshold=EDITOR_DEF("poly_editor/point_grab_radius",8);
+
+			switch(mode) {
+
+
+				case MODE_CREATE: {
+
+					if (mb.button_index==BUTTON_LEFT && mb.pressed) {
+
+
+						if (!wip_active) {
+
+							wip.clear();
+							wip.push_back( cpoint );
+							wip_active=true;
+							edited_point_pos=cpoint;
+							canvas_item_editor->get_viewport_control()->update();
+							edited_point=1;
+							return true;
+						} else {
+
+
+							if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) {
+								//wip closed
+								_wip_close(true);
+
+								return true;
+							} else if (wip.size()>1 && xform.xform(wip[wip.size()-1]).distance_to(gpoint)<grab_treshold) {
+									//wip closed
+									_wip_close(false);
+									return true;
+
+							} else {
+
+								wip.push_back( cpoint );
+								edited_point=wip.size();
+								canvas_item_editor->get_viewport_control()->update();
+								return true;
+
+								//add wip point
+							}
+						}
+					} else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) {
+						_wip_close(true);
+					}
+
+
+
+				} break;
+
+				case MODE_EDIT: {
+
+					if (mb.button_index==BUTTON_LEFT) {
+						if (mb.pressed) {
+
+							if (mb.mod.control) {
+
+
+								if (poly.size() < 3) {
+
+									undo_redo->create_action("Edit Poly");
+									undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+									poly.push_back(cpoint);
+									undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+									undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+									undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+									undo_redo->commit_action();
+									return true;
+								}
+
+								//search edges
+								int closest_idx=-1;
+								Vector2 closest_pos;
+								real_t closest_dist=1e10;
+								for(int i=0;i<poly.size();i++) {
+
+									Vector2 points[2] ={ xform.xform(poly[i]),
+										xform.xform(poly[(i+1)%poly.size()]) };
+
+									Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points);
+									if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2)
+										continue; //not valid to reuse point
+
+									real_t d = cp.distance_to(gpoint);
+									if (d<closest_dist && d<grab_treshold) {
+										closest_dist=d;
+										closest_pos=cp;
+										closest_idx=i;
+									}
+
+
+								}
+
+								if (closest_idx>=0) {
+
+									pre_move_edit=poly;
+									poly.insert(closest_idx+1,xform.affine_inverse().xform(closest_pos));
+									edited_point=closest_idx+1;
+									edited_point_pos=xform.affine_inverse().xform(closest_pos);
+									node->get_occluder_polygon()->set_polygon(Variant(poly));
+									canvas_item_editor->get_viewport_control()->update();
+									return true;
+								}
+							} else {
+
+								//look for points to move
+
+								int closest_idx=-1;
+								Vector2 closest_pos;
+								real_t closest_dist=1e10;
+								for(int i=0;i<poly.size();i++) {
+
+									Vector2 cp =xform.xform(poly[i]);
+
+									real_t d = cp.distance_to(gpoint);
+									if (d<closest_dist && d<grab_treshold) {
+										closest_dist=d;
+										closest_pos=cp;
+										closest_idx=i;
+									}
+
+								}
+
+								if (closest_idx>=0) {
+
+									pre_move_edit=poly;
+									edited_point=closest_idx;
+									edited_point_pos=xform.affine_inverse().xform(closest_pos);
+									canvas_item_editor->get_viewport_control()->update();
+									return true;
+								}
+							}
+						} else {
+
+							if (edited_point!=-1) {
+
+								//apply
+
+								ERR_FAIL_INDEX_V(edited_point,poly.size(),false);
+								poly[edited_point]=edited_point_pos;
+								undo_redo->create_action("Edit Poly");
+								undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+								undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",pre_move_edit);
+								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->commit_action();
+
+								edited_point=-1;
+								return true;
+							}
+						}
+					} if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) {
+
+
+
+						int closest_idx=-1;
+						Vector2 closest_pos;
+						real_t closest_dist=1e10;
+						for(int i=0;i<poly.size();i++) {
+
+							Vector2 cp =xform.xform(poly[i]);
+
+							real_t d = cp.distance_to(gpoint);
+							if (d<closest_dist && d<grab_treshold) {
+								closest_dist=d;
+								closest_pos=cp;
+								closest_idx=i;
+							}
+
+						}
+
+						if (closest_idx>=0) {
+
+
+							undo_redo->create_action("Edit Poly (Remove Point)");
+							undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+							poly.remove(closest_idx);
+							undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+							undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+							undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+							undo_redo->commit_action();
+							return true;
+						}
+
+					}
+
+
+
+				} break;
+			}
+
+
+
+		} break;
+		case InputEvent::MOUSE_MOTION: {
+
+			const InputEventMouseMotion &mm=p_event.mouse_motion;
+
+			if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) {
+
+				Vector2 gpoint = Point2(mm.x,mm.y);
+				Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
+				cpoint=snap_point(cpoint);
+				edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint);
+
+				canvas_item_editor->get_viewport_control()->update();
+
+			}
+
+		} break;
+	}
+
+	return false;
+}
+void LightOccluder2DEditor::_canvas_draw() {
+
+	if (!node || !node->get_occluder_polygon().is_valid())
+		return;
+
+	Control *vpc = canvas_item_editor->get_viewport_control();
+
+	Vector<Vector2> poly;
+
+	if (wip_active)
+		poly=wip;
+	else
+		poly=Variant(node->get_occluder_polygon()->get_polygon());
+
+
+	Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
+	Ref<Texture> handle= get_icon("EditorHandle","EditorIcons");
+
+	int len = poly.size();
+
+	for(int i=0;i<poly.size();i++) {
+
+
+		Vector2 p,p2;
+		p = i==edited_point ? edited_point_pos : poly[i];
+		if ((wip_active && i==poly.size()-1) || (((i+1)%poly.size())==edited_point))
+			p2=edited_point_pos;
+		else
+			p2 = poly[(i+1)%poly.size()];
+
+		Vector2 point = xform.xform(p);
+		Vector2 next_point = xform.xform(p2);
+
+		Color col=Color(1,0.3,0.1,0.8);
+
+		if (i==poly.size()-1 && (!node->get_occluder_polygon()->is_closed() || wip_active)) {
+
+		} else {
+			vpc->draw_line(point,next_point,col,2);
+		}
+		vpc->draw_texture(handle,point-handle->get_size()*0.5);
+	}
+}
+
+
+
+void LightOccluder2DEditor::edit(Node *p_collision_polygon) {
+
+	if (!canvas_item_editor) {
+		canvas_item_editor=CanvasItemEditor::get_singleton();
+	}
+
+	if (p_collision_polygon) {
+
+		node=p_collision_polygon->cast_to<LightOccluder2D>();
+		if (!canvas_item_editor->get_viewport_control()->is_connected("draw",this,"_canvas_draw"))
+			canvas_item_editor->get_viewport_control()->connect("draw",this,"_canvas_draw");
+		wip.clear();
+		wip_active=false;
+		edited_point=-1;
+		canvas_item_editor->get_viewport_control()->update();
+	} else {
+		node=NULL;
+
+		if (canvas_item_editor->get_viewport_control()->is_connected("draw",this,"_canvas_draw"))
+			canvas_item_editor->get_viewport_control()->disconnect("draw",this,"_canvas_draw");
+
+	}
+
+}
+
+void LightOccluder2DEditor::_create_poly()  {
+
+	if (!node)
+		return;
+	undo_redo->create_action("Create Occluder Polygon");
+	undo_redo->add_do_method(node,"set_occluder_polygon",Ref<OccluderPolygon2D>(memnew( OccluderPolygon2D)));
+	undo_redo->add_undo_method(node,"set_occluder_polygon",Variant(REF()));
+	undo_redo->commit_action();
+}
+
+void LightOccluder2DEditor::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("_menu_option"),&LightOccluder2DEditor::_menu_option);
+	ObjectTypeDB::bind_method(_MD("_canvas_draw"),&LightOccluder2DEditor::_canvas_draw);
+	ObjectTypeDB::bind_method(_MD("_node_removed"),&LightOccluder2DEditor::_node_removed);
+	ObjectTypeDB::bind_method(_MD("_create_poly"),&LightOccluder2DEditor::_create_poly);
+
+}
+
+
+LightOccluder2DEditor::LightOccluder2DEditor(EditorNode *p_editor) {
+
+	canvas_item_editor=NULL;
+	editor=p_editor;
+	undo_redo = editor->get_undo_redo();
+
+	add_child( memnew( VSeparator ));
+	button_create = memnew( ToolButton );
+	add_child(button_create);
+	button_create->connect("pressed",this,"_menu_option",varray(MODE_CREATE));
+	button_create->set_toggle_mode(true);
+	button_create->set_tooltip("Create a new polygon from scratch");
+
+	button_edit = memnew( ToolButton );
+	add_child(button_edit);
+	button_edit->connect("pressed",this,"_menu_option",varray(MODE_EDIT));
+	button_edit->set_toggle_mode(true);
+	button_edit->set_tooltip("Edit existing polygon:\nLMB: Move Point.\nCtrl+LMB: Split Segment.\nRMB: Erase Point.");
+
+	create_poly = memnew( ConfirmationDialog );
+	add_child(create_poly);
+	create_poly->get_ok()->set_text("Create");
+
+
+	//add_constant_override("separation",0);
+
+#if 0
+	options = memnew( MenuButton );
+	add_child(options);
+	options->set_area_as_parent_rect();
+	options->set_text("Polygon");
+	//options->get_popup()->add_item("Parse BBCODE",PARSE_BBCODE);
+	options->get_popup()->connect("item_pressed", this,"_menu_option");
+#endif
+
+	mode = MODE_EDIT;
+	wip_active=false;
+
+}
+
+
+void LightOccluder2DEditorPlugin::edit(Object *p_object) {
+
+	collision_polygon_editor->edit(p_object->cast_to<Node>());
+}
+
+bool LightOccluder2DEditorPlugin::handles(Object *p_object) const {
+
+	return p_object->is_type("LightOccluder2D");
+}
+
+void LightOccluder2DEditorPlugin::make_visible(bool p_visible) {
+
+	if (p_visible) {
+		collision_polygon_editor->show();
+	} else {
+
+		collision_polygon_editor->hide();
+		collision_polygon_editor->edit(NULL);
+	}
+
+}
+
+LightOccluder2DEditorPlugin::LightOccluder2DEditorPlugin(EditorNode *p_node) {
+
+	editor=p_node;
+	collision_polygon_editor = memnew( LightOccluder2DEditor(p_node) );
+	CanvasItemEditor::get_singleton()->add_control_to_menu_panel(collision_polygon_editor);
+
+	collision_polygon_editor->hide();
+
+
+
+}
+
+
+LightOccluder2DEditorPlugin::~LightOccluder2DEditorPlugin()
+{
+}
+

tools/editor/plugins/light_occluder_2d_editor_plugin.h

@@ -0,0 +1,87 @@
+#ifndef LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H
+#define LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H
+
+
+
+#include "tools/editor/editor_plugin.h"
+#include "tools/editor/editor_node.h"
+#include "scene/2d/light_occluder_2d.h"
+#include "scene/gui/tool_button.h"
+#include "scene/gui/button_group.h"
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+class CanvasItemEditor;
+
+class LightOccluder2DEditor : public HBoxContainer {
+
+	OBJ_TYPE(LightOccluder2DEditor, HBoxContainer );
+
+	UndoRedo *undo_redo;
+	enum Mode {
+
+		MODE_CREATE,
+		MODE_EDIT,
+
+	};
+
+	Mode mode;
+
+	ToolButton *button_create;
+	ToolButton *button_edit;
+
+	CanvasItemEditor *canvas_item_editor;
+	EditorNode *editor;
+	Panel *panel;
+	LightOccluder2D *node;
+	MenuButton *options;
+
+	int edited_point;
+	Vector2 edited_point_pos;
+	Vector<Vector2> pre_move_edit;
+	Vector<Vector2> wip;
+	bool wip_active;
+
+	ConfirmationDialog *create_poly;
+
+	void _wip_close(bool p_closed);
+	void _canvas_draw();
+	void _menu_option(int p_option);
+	void _create_poly();
+
+protected:
+	void _notification(int p_what);
+	void _node_removed(Node *p_node);
+	static void _bind_methods();
+public:
+
+	Vector2 snap_point(const Vector2& p_point) const;
+	bool forward_input_event(const InputEvent& p_event);
+	void edit(Node *p_collision_polygon);
+	LightOccluder2DEditor(EditorNode *p_editor);
+};
+
+class LightOccluder2DEditorPlugin : public EditorPlugin {
+
+	OBJ_TYPE( LightOccluder2DEditorPlugin, EditorPlugin );
+
+	LightOccluder2DEditor *collision_polygon_editor;
+	EditorNode *editor;
+
+public:
+
+	virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); }
+
+	virtual String get_name() const { return "LightOccluder2D"; }
+	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);
+
+	LightOccluder2DEditorPlugin(EditorNode *p_node);
+	~LightOccluder2DEditorPlugin();
+
+};
+
+#endif // LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H

tools/editor/plugins/navigation_polygon_editor_plugin.cpp

@@ -36,6 +36,9 @@ void NavigationPolygonEditor::_node_removed(Node *p_node) {
 
 void NavigationPolygonEditor::_create_nav()  {
 
+	if (!node)
+		return;
+
 	undo_redo->create_action("Create Navigation Polygon");
 	undo_redo->add_do_method(node,"set_navigation_polygon",Ref<NavigationPolygon>(memnew( NavigationPolygon)));
 	undo_redo->add_undo_method(node,"set_navigation_polygon",Variant(REF()));
@@ -96,7 +99,7 @@ bool NavigationPolygonEditor::forward_input_event(const InputEvent& p_event) {
 			create_nav->set_text("No NavigationPolygon resource on this node.\nCreate and assign one?");
 			create_nav->popup_centered_minsize();
 		}
-		return false;
+		return (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1);;
 	}
 
 
@@ -434,6 +437,7 @@ void NavigationPolygonEditor::edit(Node *p_collision_polygon) {
 		wip.clear();
 		wip_active=false;
 		edited_point=-1;
+		canvas_item_editor->get_viewport_control()->update();
 
 	} else {
 		node=NULL;

tools/editor/plugins/script_editor_plugin.cpp

@@ -630,11 +630,13 @@ bool ScriptEditor::_test_script_times_on_disk() {
 
 
 
-	if (!all_ok)
-		if (bool(EDITOR_DEF("text_editor/auto_reload_changed_scripts",false)))
+	if (!all_ok) {
+		if (bool(EDITOR_DEF("text_editor/auto_reload_changed_scripts",false))) {
 			script_editor->_reload_scripts();
-		else
+		} else {
 			disk_changed->call_deferred("popup_centered_ratio",0.5);
+		}
+	}
 
 	return all_ok;
 }
@@ -920,7 +922,7 @@ void ScriptEditor::_menu_option(int p_option) {
                     String line_text = tx->get_line(i);
 
                     if (line_text.begins_with("#"))
-                        line_text = line_text.strip_edges().substr(1, line_text.length());
+                        line_text = line_text.substr(1, line_text.length());
                     else
                         line_text = "#" + line_text;
                     tx->set_line(i, line_text);
@@ -932,7 +934,7 @@ void ScriptEditor::_menu_option(int p_option) {
                 String line_text = tx->get_line(begin);
 
                 if (line_text.begins_with("#"))
-                    line_text = line_text.strip_edges().substr(1, line_text.length());
+                    line_text = line_text.substr(1, line_text.length());
                 else
                     line_text = "#" + line_text;
                 tx->set_line(begin, line_text);

tools/editor/plugins/spatial_editor_plugin.cpp

@@ -477,6 +477,16 @@ void SpatialEditorViewport::_select_region() {
 
 }
 
+void SpatialEditorViewport::_update_name() {
+
+	String ortho = orthogonal?"Orthogonal":"Perspective";
+
+	if (name!="")
+		view_menu->set_text("[ "+name+" "+ortho+" ]");
+	else
+		view_menu->set_text("[ "+ortho+" ]");
+}
+
 
 void SpatialEditorViewport::_compute_edit(const Point2& p_point) {
 
@@ -832,6 +842,8 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 
 								_edit.plane=TRANSFORM_X_AXIS;
 								set_message("View Plane Transform.",2);
+								name="";
+								_update_name();
 							} break;
 							case TRANSFORM_X_AXIS: {
 
@@ -1460,6 +1472,8 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 						cursor.x_rot=Math_PI/2.0;
 					if (cursor.x_rot<-Math_PI/2.0)
 						cursor.x_rot=-Math_PI/2.0;
+					name="";
+					_update_name();
 				} break;
 
 				default: {}
@@ -1484,9 +1498,14 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 					if (k.mod.shift) {
 						cursor.x_rot=-Math_PI/2.0;
 						set_message("Bottom View.",2);
+						name="Bottom";
+						_update_name();
+
 					} else {
 						cursor.x_rot=Math_PI/2.0;
 						set_message("Top View.",2);
+						name="Top";
+						_update_name();
 					}
 				} break;
 				case KEY_KP_1: {
@@ -1495,10 +1514,14 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 					if (k.mod.shift) {
 						cursor.y_rot=Math_PI;
 						set_message("Rear View.",2);
+						name="Rear";
+						_update_name();
 
 					} else {
 						cursor.y_rot=0;
 						set_message("Front View.",2);
+						name="Front";
+						_update_name();
 					}
 
 				} break;
@@ -1508,9 +1531,13 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 					if (k.mod.shift) {
 						cursor.y_rot=Math_PI/2.0;
 						set_message("Left View.",2);
+						name="Left";
+						_update_name();
 					} else {
 						cursor.y_rot=-Math_PI/2.0;
 						set_message("Right View.",2);
+						name="Right";
+						_update_name();
 					}
 
 				} break;
@@ -1518,6 +1545,7 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 
 					orthogonal = !orthogonal;
 					_menu_option(orthogonal?VIEW_PERSPECTIVE:VIEW_ORTHOGONAL);
+					_update_name();
 
 
 				} break;
@@ -1831,35 +1859,47 @@ void SpatialEditorViewport::_menu_option(int p_option) {
 
 			cursor.x_rot=Math_PI/2.0;
 			cursor.y_rot=0;
+			name="Top";
+			_update_name();
 		} break;
 		case VIEW_BOTTOM: {
 
 			cursor.x_rot=-Math_PI/2.0;
 			cursor.y_rot=0;
+			name="Bottom";
+			_update_name();
 
 		} break;
 		case VIEW_LEFT: {
 
 			cursor.y_rot=Math_PI/2.0;
 			cursor.x_rot=0;
+			name="Left";
+			_update_name();
 
 		} break;
 		case VIEW_RIGHT: {
 
 			cursor.y_rot=-Math_PI/2.0;
 			cursor.x_rot=0;
+			name="Right";
+			_update_name();
 
 		} break;
 		case VIEW_FRONT: {
 
 			cursor.y_rot=0;
 			cursor.x_rot=0;
+			name="Front";
+			_update_name();
 
 		} break;
 		case VIEW_REAR: {
 
 			cursor.y_rot=Math_PI;
 			cursor.x_rot=0;
+			name="Rear";
+			_update_name();
 
 		} break;
 		case VIEW_CENTER_TO_SELECTION: {
@@ -1941,6 +1981,7 @@ void SpatialEditorViewport::_menu_option(int p_option) {
 			view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ORTHOGONAL), false );
 			orthogonal=false;
 			call_deferred("update_transform_gizmo_view");
+			_update_name();
 
 		} break;
 		case VIEW_ORTHOGONAL: {
@@ -1949,6 +1990,7 @@ void SpatialEditorViewport::_menu_option(int p_option) {
 			view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ORTHOGONAL), true );
 			orthogonal=true;
 			call_deferred("update_transform_gizmo_view");
+			_update_name();
 
 		} break;
 		case VIEW_AUDIO_LISTENER: {
@@ -2147,15 +2189,13 @@ void SpatialEditorViewport::reset() {
 	message_time=0;
 	message="";
 	last_message="";
+	name="Top";
 
 	cursor.x_rot=0;
 	cursor.y_rot=0;
 	cursor.distance=4;
 	cursor.region_select=false;
-
-
-
-
+	_update_name();
 }
 
 SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, EditorNode *p_editor, int p_index) {
@@ -2189,18 +2229,17 @@ SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, Ed
 	view_menu = memnew( MenuButton );
 	surface->add_child(view_menu);
 	view_menu->set_pos( Point2(4,4));
-	view_menu->set_text("[view]");
 	view_menu->set_self_opacity(0.5);
 
-	view_menu->get_popup()->add_item("Top",VIEW_TOP);
-	view_menu->get_popup()->add_item("Bottom",VIEW_BOTTOM);
-	view_menu->get_popup()->add_item("Left",VIEW_LEFT);
-	view_menu->get_popup()->add_item("Right",VIEW_RIGHT);
-	view_menu->get_popup()->add_item("Front",VIEW_FRONT);
-	view_menu->get_popup()->add_item("Rear",VIEW_REAR);
+	view_menu->get_popup()->add_item("Top (Num7)",VIEW_TOP);
+	view_menu->get_popup()->add_item("Bottom (Shift+Num7)",VIEW_BOTTOM);
+	view_menu->get_popup()->add_item("Left (Num3)",VIEW_LEFT);
+	view_menu->get_popup()->add_item("Right (Shift+Num3)",VIEW_RIGHT);
+	view_menu->get_popup()->add_item("Front (Num1)",VIEW_FRONT);
+	view_menu->get_popup()->add_item("Rear (Shift+Num1)",VIEW_REAR);
 	view_menu->get_popup()->add_separator();
-	view_menu->get_popup()->add_check_item("Perspective",VIEW_PERSPECTIVE);
-	view_menu->get_popup()->add_check_item("Orthogonal",VIEW_ORTHOGONAL);
+	view_menu->get_popup()->add_check_item("Perspective (Num5)",VIEW_PERSPECTIVE);
+	view_menu->get_popup()->add_check_item("Orthogonal (Num5)",VIEW_ORTHOGONAL);
 	view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(VIEW_PERSPECTIVE),true);
 	view_menu->get_popup()->add_separator();
 	view_menu->get_popup()->add_check_item("Environment",VIEW_ENVIRONMENT);
@@ -2233,6 +2272,10 @@ SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, Ed
 		viewport->set_as_audio_listener(true);
 	}
 
+
+	name="Top";
+	_update_name();
+
 	EditorSettings::get_singleton()->connect("settings_changed",this,"update_transform_gizmo_view");
 
 }
@@ -3666,7 +3709,7 @@ SpatialEditor::SpatialEditor(EditorNode *p_editor) {
 	p->add_check_item("View Origin",MENU_VIEW_ORIGIN);
 	p->add_check_item("View Grid",MENU_VIEW_GRID);
 	p->add_separator();
-	p->add_check_item("Settings",MENU_VIEW_CAMERA_SETTINGS );
+	p->add_item("Settings",MENU_VIEW_CAMERA_SETTINGS);
 
 
 	p->set_item_checked( p->get_item_index(MENU_VIEW_USE_DEFAULT_LIGHT), true );

tools/editor/plugins/spatial_editor_plugin.h

@@ -92,6 +92,7 @@ public:
 	};
 private:
 	int index;
+	String name;
 	void _menu_option(int p_option);
 	Size2 prev_size;
 
@@ -110,6 +111,7 @@ private:
 	bool orthogonal;
 	float gizmo_scale;
 
+	void _update_name();
 	void _compute_edit(const Point2& p_point);
 	void _clear_selected();
 	void _select_clicked(bool p_append,bool p_single);

tools/editor/plugins/theme_editor_plugin.cpp

@@ -568,6 +568,26 @@ ThemeEditor::ThemeEditor() {
 	CheckButton *cb = memnew( CheckButton );
 	cb->set_text("CheckButton");
 	first_vb->add_child(cb );
+    CheckBox *cbx = memnew( CheckBox );
+    cbx->set_text("CheckBox");
+    first_vb->add_child(cbx );
+
+    /* TODO: This is not working properly, controls are overlapping*/
+    /*
+    ButtonGroup *bg = memnew( ButtonGroup );
+    bg->set_v_size_flags(SIZE_EXPAND_FILL);
+    VBoxContainer *gbvb = memnew( VBoxContainer );
+    gbvb->set_v_size_flags(SIZE_EXPAND_FILL);
+    CheckBox *rbx1 = memnew( CheckBox );
+    rbx1->set_text("CheckBox Radio1");
+    rbx1->set_pressed(true);
+    gbvb->add_child(rbx1);
+    CheckBox *rbx2 = memnew( CheckBox );
+    rbx2->set_text("CheckBox Radio2");
+    gbvb->add_child(rbx2);
+    bg->add_child(gbvb);
+    first_vb->add_child(bg);
+    */
 
 	MenuButton* test_menu_button = memnew( MenuButton );
 	test_menu_button->set_text("MenuButton");

tools/editor/plugins/theme_editor_plugin.h

@@ -33,6 +33,8 @@
 #include "scene/gui/texture_frame.h"
 #include "scene/gui/option_button.h"
 #include "scene/gui/file_dialog.h"
+#include "scene/gui/check_box.h"
+#include "scene/gui/button_group.h"
 
 #include "tools/editor/editor_node.h"
 

tools/editor/plugins/tile_map_editor_plugin.cpp

@@ -640,19 +640,53 @@ void TileMapEditor::_canvas_draw() {
 
 					Ref<Texture> t = ts->tile_get_texture(st);
 					if (t.is_valid()) {
-						Vector2 from = xform.xform(ts->tile_get_texture_offset(st)+node->map_to_world(over_tile)+node->get_cell_draw_offset());
+						Vector2 from = node->map_to_world(over_tile)+node->get_cell_draw_offset();
 						Rect2 r = ts->tile_get_region(st);												
 						Size2 sc = xform.get_scale();
 						if (mirror_x->is_pressed())
 							sc.x*=-1.0;
 						if (mirror_y->is_pressed())
 							sc.y*=-1.0;
-						if (r==Rect2()) {
 
-							canvas_item_editor->draw_texture_rect(t,Rect2(from,t->get_size()*sc),false,Color(1,1,1,0.5),transpose->is_pressed());
+						Rect2 rect;
+						if (r==Rect2()) {
+							rect=Rect2(from,t->get_size());
 						} else {
 
-							canvas_item_editor->draw_texture_rect_region(t,Rect2(from,r.get_size()*sc),r,Color(1,1,1,0.5),transpose->is_pressed());
+							rect=Rect2(from,r.get_size());
+						}
+
+
+						if (node->get_tile_origin()==TileMap::TILE_ORIGIN_TOP_LEFT) {
+							rect.pos+=ts->tile_get_texture_offset(st);
+
+						} else if (node->get_tile_origin()==TileMap::TILE_ORIGIN_CENTER) {
+							rect.pos+=node->get_cell_size()/2;
+							Vector2 s = r.size;
+
+							Vector2 center = (s/2) - ts->tile_get_texture_offset(st);
+
+
+							if (mirror_x->is_pressed())
+								rect.pos.x-=s.x-center.x;
+							else
+								rect.pos.x-=center.x;
+
+							if (mirror_y->is_pressed())
+								rect.pos.y-=s.y-center.y;
+							else
+								rect.pos.y-=center.y;
+						}
+
+						rect.pos=xform.xform(rect.pos);
+						rect.size*=sc;
+
+						if (r==Rect2()) {
+
+							canvas_item_editor->draw_texture_rect(t,rect,false,Color(1,1,1,0.5),transpose->is_pressed());
+						} else {
+
+							canvas_item_editor->draw_texture_rect_region(t,rect,r,Color(1,1,1,0.5),transpose->is_pressed());
 						}
 					}
 				}

tools/editor/plugins/tile_set_editor_plugin.cpp

@@ -37,83 +37,103 @@ void TileSetEditor::edit(const Ref<TileSet>& p_tileset) {
 void TileSetEditor::_import_scene(Node *scene, Ref<TileSet> p_library, bool p_merge) {
 
 	if (!p_merge)
-	       p_library->clear();
+		p_library->clear();
 
 	for(int i=0;i<scene->get_child_count();i++) {
 
 
-	       Node *child = scene->get_child(i);
+		Node *child = scene->get_child(i);
 
 
-	       if (!child->cast_to<Sprite>()) {
-		       if (child->get_child_count()>0) {
-			       child=child->get_child(0);
-			       if (!child->cast_to<Sprite>()) {
-				       continue;
-			       }
+		if (!child->cast_to<Sprite>()) {
+			if (child->get_child_count()>0) {
+				child=child->get_child(0);
+				if (!child->cast_to<Sprite>()) {
+					continue;
+				}
 
-		       } else
-			       continue;
+			} else
+				continue;
 
 
-	       }
+		}
 
-	       Sprite *mi = child->cast_to<Sprite>();
-	       Ref<Texture> texture=mi->get_texture();
-	       if (texture.is_null())
+		Sprite *mi = child->cast_to<Sprite>();
+		Ref<Texture> texture=mi->get_texture();
+		Ref<CanvasItemMaterial> material=mi->get_material();
+
+		if (texture.is_null())
 			continue;
 
-	       int id = p_library->find_tile_by_name(mi->get_name());
-	       if (id<0) {
+		int id = p_library->find_tile_by_name(mi->get_name());
+		if (id<0) {
 
-		       id=p_library->get_last_unused_tile_id();
-		       p_library->create_tile(id);
-		       p_library->tile_set_name(id,mi->get_name());
-	       }
+			id=p_library->get_last_unused_tile_id();
+			p_library->create_tile(id);
+			p_library->tile_set_name(id,mi->get_name());
+		}
 
 
-	       p_library->tile_set_texture(id,texture);
-	       Vector2 phys_offset;
 
-	       if (mi->is_centered()) {
-		       Size2 s;
-		       if (mi->is_region()) {
-			       s=mi->get_region_rect().size;
-		       } else {
-			       s=texture->get_size();
-		       }
-		       phys_offset+=-s/2;
-	       }
-	       if (mi->is_region()) {
-		       p_library->tile_set_region(id,mi->get_region_rect());
-	       }
+		p_library->tile_set_texture(id,texture);
+		p_library->tile_set_material(id,material);
 
-	       Vector<Ref<Shape2D> >collisions;
+		Vector2 phys_offset;
 
-	       for(int j=0;j<mi->get_child_count();j++) {
-
-		       Node *child2 = mi->get_child(j);
-		       if (!child2->cast_to<StaticBody2D>())
-			       continue;
-		       StaticBody2D *sb = child2->cast_to<StaticBody2D>();
-		       if (sb->get_shape_count()==0)
-			       continue;
-		       Ref<Shape2D> collision=sb->get_shape(0);
-		       if (collision.is_valid()) {
-			       collisions.push_back(collision);
+		if (mi->is_centered()) {
+			Size2 s;
+			if (mi->is_region()) {
+				s=mi->get_region_rect().size;
+			} else {
+				s=texture->get_size();
 			}
-	       }
+			phys_offset+=-s/2;
+		}
+		if (mi->is_region()) {
+			p_library->tile_set_region(id,mi->get_region_rect());
+		}
 
-	       if (collisions.size()) {
+		Vector<Ref<Shape2D> >collisions;
+		Ref<NavigationPolygon> nav_poly;
+		Ref<OccluderPolygon2D> occluder;
 
-		       p_library->tile_set_shapes(id,collisions);
-		       p_library->tile_set_shape_offset(id,-phys_offset);
-	       } else {
-		       p_library->tile_set_shape_offset(id,Vector2());
+		for(int j=0;j<mi->get_child_count();j++) {
+
+			Node *child2 = mi->get_child(j);
+
+			if (child2->cast_to<NavigationPolygonInstance>())
+				nav_poly=child2->cast_to<NavigationPolygonInstance>()->get_navigation_polygon();
+
+			if (child2->cast_to<LightOccluder2D>())
+				occluder=child2->cast_to<LightOccluder2D>()->get_occluder_polygon();
+
+			if (!child2->cast_to<StaticBody2D>())
+				continue;
+			StaticBody2D *sb = child2->cast_to<StaticBody2D>();
+			if (sb->get_shape_count()==0)
+				continue;
+			Ref<Shape2D> collision=sb->get_shape(0);
+			if (collision.is_valid()) {
+				collisions.push_back(collision);
+			}
+		}
+
+		if (collisions.size()) {
+
+			p_library->tile_set_shapes(id,collisions);
+			p_library->tile_set_shape_offset(id,-phys_offset);
+		} else {
+			p_library->tile_set_shape_offset(id,Vector2());
+
+		}
+
+		p_library->tile_set_texture_offset(id,mi->get_offset());
+		p_library->tile_set_navigation_polygon(id,nav_poly);
+		p_library->tile_set_light_occluder(id,occluder);
+		p_library->tile_set_occluder_offset(id,-phys_offset);
+		p_library->tile_set_navigation_polygon_offset(id,-phys_offset);
 
-	       }
 
-	       p_library->tile_set_texture_offset(id,mi->get_offset());
 	}
 }
 
@@ -121,23 +141,23 @@ void TileSetEditor::_menu_confirm() {
 
 	switch(option) {
 
-		 case MENU_OPTION_REMOVE_ITEM: {
+		case MENU_OPTION_REMOVE_ITEM: {
 
-			 tileset->remove_tile(to_erase);
-		 } break;
-		 case MENU_OPTION_MERGE_FROM_SCENE:
-		 case MENU_OPTION_CREATE_FROM_SCENE: {
+			tileset->remove_tile(to_erase);
+		} break;
+		case MENU_OPTION_MERGE_FROM_SCENE:
+		case MENU_OPTION_CREATE_FROM_SCENE: {
 
 
-			 EditorNode *en = editor;
-			 Node * scene = en->get_edited_scene();
-			 if (!scene)
-				 break;
+			EditorNode *en = editor;
+			Node * scene = en->get_edited_scene();
+			if (!scene)
+				break;
 
-			 _import_scene(scene,tileset,option==MENU_OPTION_MERGE_FROM_SCENE);
+			_import_scene(scene,tileset,option==MENU_OPTION_MERGE_FROM_SCENE);
 
 
-		 } break;
+		} break;
 	}
 }
 
@@ -165,11 +185,11 @@ void TileSetEditor::_menu_cbk(int p_option) {
 			cd->set_text("Create from scene?");
 			cd->popup_centered(Size2(300,60));
 		} break;
-		 case MENU_OPTION_MERGE_FROM_SCENE: {
+		case MENU_OPTION_MERGE_FROM_SCENE: {
 
-			 cd->set_text("Merge from scene?");
-			 cd->popup_centered(Size2(300,60));
-		 } break;
+			cd->set_text("Merge from scene?");
+			cd->popup_centered(Size2(300,60));
+		} break;
 	}
 }
 

tools/editor/plugins/tile_set_editor_plugin.h

@@ -56,7 +56,7 @@ class TileSetEditor : public Control {
 
 	int option;
 	void _menu_cbk(int p_option);
-	void _menu_confirm();
+	void _menu_confirm();	
 
 	static void _import_scene(Node *p_scene, Ref<TileSet> p_library, bool p_merge);