Merge pull request #8901 from tagcup/path_editor_plugin

Revive PathEditorPlugin.

editor/editor_node.cpp

@@ -5944,7 +5944,7 @@ EditorNode::EditorNode() {
 	add_editor_plugin(memnew(Particles2DEditorPlugin(this)));
 	add_editor_plugin(memnew(GIProbeEditorPlugin(this)));
 	add_editor_plugin(memnew(Path2DEditorPlugin(this)));
-	//add_editor_plugin( memnew( PathEditorPlugin(this) ) );
+	add_editor_plugin(memnew(PathEditorPlugin(this)));
 	//add_editor_plugin( memnew( BakedLightEditorPlugin(this) ) );
 	add_editor_plugin(memnew(Line2DEditorPlugin(this)));
 	add_editor_plugin(memnew(Polygon2DEditorPlugin(this)));

editor/plugins/path_editor_plugin.cpp

@@ -33,61 +33,57 @@
 #include "scene/resources/curve.h"
 #include "spatial_editor_plugin.h"
 
-#if 0
 String PathSpatialGizmo::get_handle_name(int p_idx) const {
 
 	Ref<Curve3D> c = path->get_curve();
 	if (c.is_null())
 		return "";
 
-	if (p_idx<c->get_point_count()) {
+	if (p_idx < c->get_point_count()) {
 
-		return TTR("Curve Point #")+itos(p_idx);
+		return TTR("Curve Point #") + itos(p_idx);
 	}
 
-	p_idx=p_idx-c->get_point_count()+1;
+	p_idx = p_idx - c->get_point_count() + 1;
 
-	int idx=p_idx/2;
-	int t=p_idx%2;
-	String n = TTR("Curve Point #")+itos(idx);
-	if (t==0)
-		n+=" In";
+	int idx = p_idx / 2;
+	int t = p_idx % 2;
+	String n = TTR("Curve Point #") + itos(idx);
+	if (t == 0)
+		n += " In";
 	else
-		n+=" Out";
+		n += " Out";
 
 	return n;
-
-
 }
-Variant PathSpatialGizmo::get_handle_value(int p_idx) const{
+Variant PathSpatialGizmo::get_handle_value(int p_idx) const {
 
 	Ref<Curve3D> c = path->get_curve();
 	if (c.is_null())
 		return Variant();
 
-	if (p_idx<c->get_point_count()) {
+	if (p_idx < c->get_point_count()) {
 
-		original=c->get_point_pos(p_idx);
+		original = c->get_point_pos(p_idx);
 		return original;
 	}
 
-	p_idx=p_idx-c->get_point_count()+1;
+	p_idx = p_idx - c->get_point_count() + 1;
 
-	int idx=p_idx/2;
-	int t=p_idx%2;
+	int idx = p_idx / 2;
+	int t = p_idx % 2;
 
 	Vector3 ofs;
-	if (t==0)
-		ofs=c->get_point_in(idx);
+	if (t == 0)
+		ofs = c->get_point_in(idx);
 	else
-		ofs= c->get_point_out(idx);
+		ofs = c->get_point_out(idx);
 
-	original=ofs+c->get_point_pos(idx);
+	original = ofs + c->get_point_pos(idx);
 
 	return ofs;
-
 }
-void PathSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
+void PathSpatialGizmo::set_handle(int p_idx, Camera *p_camera, const Point2 &p_point) {
 
 	Ref<Curve3D> c = path->get_curve();
 	if (c.is_null())
@@ -98,51 +94,49 @@ void PathSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_po
 	Vector3 ray_from = p_camera->project_ray_origin(p_point);
 	Vector3 ray_dir = p_camera->project_ray_normal(p_point);
 
-	if (p_idx<c->get_point_count()) {
+	if (p_idx < c->get_point_count()) {
 
-		Plane p(gt.xform(original),p_camera->get_transform().basis.get_axis(2));
+		Plane p(gt.xform(original), p_camera->get_transform().basis.get_axis(2));
 
 		Vector3 inters;
 
-		if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+		if (p.intersects_ray(ray_from, ray_dir, &inters)) {
 
-			if(SpatialEditor::get_singleton()->is_snap_enabled())
-			{
+			if (SpatialEditor::get_singleton()->is_snap_enabled()) {
 				float snap = SpatialEditor::get_singleton()->get_translate_snap();
 				inters.snap(snap);
 			}
-			
+
 			Vector3 local = gi.xform(inters);
-			c->set_point_pos(p_idx,local);
+			c->set_point_pos(p_idx, local);
 		}
 
 		return;
 	}
 
-	p_idx=p_idx-c->get_point_count()+1;
+	p_idx = p_idx - c->get_point_count() + 1;
 
-	int idx=p_idx/2;
-	int t=p_idx%2;
+	int idx = p_idx / 2;
+	int t = p_idx % 2;
 
 	Vector3 base = c->get_point_pos(idx);
 
-	Plane p(gt.xform(original),p_camera->get_transform().basis.get_axis(2));
+	Plane p(gt.xform(original), p_camera->get_transform().basis.get_axis(2));
 
 	Vector3 inters;
 
-	if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+	if (p.intersects_ray(ray_from, ray_dir, &inters)) {
 
-		Vector3 local = gi.xform(inters)-base;
-		if (t==0) {
-			c->set_point_in(idx,local);
+		Vector3 local = gi.xform(inters) - base;
+		if (t == 0) {
+			c->set_point_in(idx, local);
 		} else {
-			c->set_point_out(idx,local);
+			c->set_point_out(idx, local);
 		}
 	}
-
 }
 
-void PathSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
+void PathSpatialGizmo::commit_handle(int p_idx, const Variant &p_restore, bool p_cancel) {
 
 	Ref<Curve3D> c = path->get_curve();
 	if (c.is_null())
@@ -150,67 +144,59 @@ void PathSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_c
 
 	UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
 
-	if (p_idx<c->get_point_count()) {
+	if (p_idx < c->get_point_count()) {
 
 		if (p_cancel) {
 
-			c->set_point_pos(p_idx,p_restore);
+			c->set_point_pos(p_idx, p_restore);
 			return;
 		}
 		ur->create_action(TTR("Set Curve Point Pos"));
-		ur->add_do_method(c.ptr(),"set_point_pos",p_idx,c->get_point_pos(p_idx));
-		ur->add_undo_method(c.ptr(),"set_point_pos",p_idx,p_restore);
+		ur->add_do_method(c.ptr(), "set_point_pos", p_idx, c->get_point_pos(p_idx));
+		ur->add_undo_method(c.ptr(), "set_point_pos", p_idx, p_restore);
 		ur->commit_action();
 
 		return;
 	}
 
-	p_idx=p_idx-c->get_point_count()+1;
+	p_idx = p_idx - c->get_point_count() + 1;
 
-	int idx=p_idx/2;
-	int t=p_idx%2;
+	int idx = p_idx / 2;
+	int t = p_idx % 2;
 
 	Vector3 ofs;
 
 	if (p_cancel) {
 
-
-
 		return;
 	}
 
-
-
-	if (t==0) {
+	if (t == 0) {
 
 		if (p_cancel) {
 
-			c->set_point_in(p_idx,p_restore);
+			c->set_point_in(p_idx, p_restore);
 			return;
 		}
 		ur->create_action(TTR("Set Curve In Pos"));
-		ur->add_do_method(c.ptr(),"set_point_in",idx,c->get_point_in(idx));
-		ur->add_undo_method(c.ptr(),"set_point_in",idx,p_restore);
+		ur->add_do_method(c.ptr(), "set_point_in", idx, c->get_point_in(idx));
+		ur->add_undo_method(c.ptr(), "set_point_in", idx, p_restore);
 		ur->commit_action();
 
-
 	} else {
 		if (p_cancel) {
 
-			c->set_point_out(idx,p_restore);
+			c->set_point_out(idx, p_restore);
 			return;
 		}
 		ur->create_action(TTR("Set Curve Out Pos"));
-		ur->add_do_method(c.ptr(),"set_point_out",idx,c->get_point_out(idx));
-		ur->add_undo_method(c.ptr(),"set_point_out",idx,p_restore);
+		ur->add_do_method(c.ptr(), "set_point_out", idx, c->get_point_out(idx));
+		ur->add_undo_method(c.ptr(), "set_point_out", idx, p_restore);
 		ur->commit_action();
-
 	}
-
 }
 
-
-void PathSpatialGizmo::redraw(){
+void PathSpatialGizmo::redraw() {
 
 	clear();
 
@@ -218,80 +204,76 @@ void PathSpatialGizmo::redraw(){
 	if (c.is_null())
 		return;
 
-	Vector3Array v3a=c->tesselate();
-	//Vector3Array v3a=c->get_baked_points();
+	PoolVector<Vector3> v3a = c->tesselate();
+	//PoolVector<Vector3> v3a=c->get_baked_points();
 
 	int v3s = v3a.size();
-	if (v3s==0)
+	if (v3s == 0)
 		return;
 	Vector<Vector3> v3p;
-	Vector3Array::Read r = v3a.read();
+	PoolVector<Vector3>::Read r = v3a.read();
 
-	for(int i=0;i<v3s-1;i++) {
+	// BUG: the following won't work when v3s, avoid drawing as a temporary workaround.
+	for (int i = 0; i < v3s - 1; i++) {
 
 		v3p.push_back(r[i]);
-		v3p.push_back(r[i+1]);
+		v3p.push_back(r[i + 1]);
 		//v3p.push_back(r[i]);
 		//v3p.push_back(r[i]+Vector3(0,0.2,0));
 	}
 
-	add_lines(v3p,PathEditorPlugin::singleton->path_material);
+	add_lines(v3p, PathEditorPlugin::singleton->path_material);
 	add_collision_segments(v3p);
 
-	if (PathEditorPlugin::singleton->get_edited_path()==path) {
+	if (PathEditorPlugin::singleton->get_edited_path() == path) {
 		v3p.clear();
 		Vector<Vector3> handles;
 		Vector<Vector3> sec_handles;
 
-		for(int i=0;i<c->get_point_count();i++) {
+		for (int i = 0; i < c->get_point_count(); i++) {
 
 			Vector3 p = c->get_point_pos(i);
 			handles.push_back(p);
-			if (i>0) {
+			if (i > 0) {
 				v3p.push_back(p);
-				v3p.push_back(p+c->get_point_in(i));
-				sec_handles.push_back(p+c->get_point_in(i));
+				v3p.push_back(p + c->get_point_in(i));
+				sec_handles.push_back(p + c->get_point_in(i));
 			}
 
-			if (i<c->get_point_count()-1) {
+			if (i < c->get_point_count() - 1) {
 				v3p.push_back(p);
-				v3p.push_back(p+c->get_point_out(i));
-				sec_handles.push_back(p+c->get_point_out(i));
+				v3p.push_back(p + c->get_point_out(i));
+				sec_handles.push_back(p + c->get_point_out(i));
 			}
 		}
 
-		add_lines(v3p,PathEditorPlugin::singleton->path_thin_material);
+		add_lines(v3p, PathEditorPlugin::singleton->path_thin_material);
 		add_handles(handles);
-		add_handles(sec_handles,false,true);
+		add_handles(sec_handles, false, true);
 	}
-
 }
 
-PathSpatialGizmo::PathSpatialGizmo(Path* p_path){
+PathSpatialGizmo::PathSpatialGizmo(Path *p_path) {
 
-	path=p_path;
+	path = p_path;
 	set_spatial_node(p_path);
-
-
-
 }
 
-Ref<SpatialEditorGizmo> PathEditorPlugin::create_spatial_gizmo(Spatial* p_spatial) {
-
+Ref<SpatialEditorGizmo> PathEditorPlugin::create_spatial_gizmo(Spatial *p_spatial) {
 
 	if (p_spatial->cast_to<Path>()) {
 
-		return memnew( PathSpatialGizmo(p_spatial->cast_to<Path>()));
+		return memnew(PathSpatialGizmo(p_spatial->cast_to<Path>()));
 	}
 
 	return Ref<SpatialEditorGizmo>();
 }
 
-bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEvent& p_event) {
+bool PathEditorPlugin::forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event) {
 
 	if (!path)
 		return false;
-	Ref<Curve3D> c=path->get_curve();
+	Ref<Curve3D> c = path->get_curve();
 	if (c.is_null())
 		return false;
 	Transform gt = path->get_global_transform();
@@ -299,105 +281,99 @@ bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEve
 
 	static const int click_dist = 10; //should make global
 
+	Ref<InputEventMouseButton> mb = p_event;
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON) {
+	if (mb.is_valid()) {
 
-		const InputEventMouseButton &mb=p_event.mouse_button;
-		Point2 mbpos(mb->get_pos().x,mb->get_pos().y);
+		Point2 mbpos(mb->get_pos().x, mb->get_pos().y);
 
-		if (mb->is_pressed() && mb->get_button_index()==BUTTON_LEFT && (curve_create->is_pressed() || (curve_edit->is_pressed() && mb->get_control()))) {
+		if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && (curve_create->is_pressed() || (curve_edit->is_pressed() && mb->get_control()))) {
 			//click into curve, break it down
-			Vector3Array v3a = c->tesselate();
-			int idx=0;
-			int rc=v3a.size();
-			int closest_seg=-1;
+			PoolVector<Vector3> v3a = c->tesselate();
+			int idx = 0;
+			int rc = v3a.size();
+			int closest_seg = -1;
 			Vector3 closest_seg_point;
-			float closest_d=1e20;
+			float closest_d = 1e20;
 
-			if (rc>=2) {
-				Vector3Array::Read r = v3a.read();
+			if (rc >= 2) {
+				PoolVector<Vector3>::Read r = v3a.read();
 
-				if (p_camera->unproject_position(gt.xform(c->get_point_pos(0))).distance_to(mbpos)<click_dist)
+				if (p_camera->unproject_position(gt.xform(c->get_point_pos(0))).distance_to(mbpos) < click_dist)
 					return false; //nope, existing
 
-
-				for(int i=0;i<c->get_point_count()-1;i++) {
+				for (int i = 0; i < c->get_point_count() - 1; i++) {
 					//find the offset and point index of the place to break up
-					int j=idx;
-					if (p_camera->unproject_position(gt.xform(c->get_point_pos(i+1))).distance_to(mbpos)<click_dist)
+					int j = idx;
+					if (p_camera->unproject_position(gt.xform(c->get_point_pos(i + 1))).distance_to(mbpos) < click_dist)
 						return false; //nope, existing
 
+					while (j < rc && c->get_point_pos(i + 1) != r[j]) {
 
-					while(j<rc && c->get_point_pos(i+1)!=r[j]) {
-
-						Vector3 from =r[j];
-						Vector3 to =r[j+1];
+						Vector3 from = r[j];
+						Vector3 to = r[j + 1];
 						real_t cdist = from.distance_to(to);
-						from=gt.xform(from);
-						to=gt.xform(to);
-						if (cdist>0) {
+						from = gt.xform(from);
+						to = gt.xform(to);
+						if (cdist > 0) {
 							Vector2 s[2];
 							s[0] = p_camera->unproject_position(from);
 							s[1] = p_camera->unproject_position(to);
-							Vector2 inters = Geometry::get_closest_point_to_segment_2d(mbpos,s);
+							Vector2 inters = Geometry::get_closest_point_to_segment_2d(mbpos, s);
 							float d = inters.distance_to(mbpos);
 
-							if (d<10 && d<closest_d) {
+							if (d < 10 && d < closest_d) {
 
+								closest_d = d;
+								closest_seg = i;
+								Vector3 ray_from = p_camera->project_ray_origin(mbpos);
+								Vector3 ray_dir = p_camera->project_ray_normal(mbpos);
 
-								closest_d=d;
-								closest_seg=i;
-								Vector3 ray_from=p_camera->project_ray_origin(mbpos);
-								Vector3 ray_dir=p_camera->project_ray_normal(mbpos);
+								Vector3 ra, rb;
+								Geometry::get_closest_points_between_segments(ray_from, ray_from + ray_dir * 4096, from, to, ra, rb);
 
-								Vector3 ra,rb;
-								Geometry::get_closest_points_between_segments(ray_from,ray_from+ray_dir*4096,from,to,ra,rb);
-
-								closest_seg_point=it.xform(rb);
+								closest_seg_point = it.xform(rb);
 							}
-
 						}
 						j++;
-
 					}
-					if (idx==j)
+					if (idx == j)
 						idx++; //force next
 					else
-						idx=j; //swap
+						idx = j; //swap
 
-
-					if (j==rc)
+					if (j == rc)
 						break;
 				}
 			}
 
 			UndoRedo *ur = editor->get_undo_redo();
-			if (closest_seg!=-1) {
+			if (closest_seg != -1) {
 				//subdivide
 
 				ur->create_action(TTR("Split Path"));
-				ur->add_do_method(c.ptr(),"add_point",closest_seg_point,Vector3(),Vector3(),closest_seg+1);
-				ur->add_undo_method(c.ptr(),"remove_point",closest_seg+1);
+				ur->add_do_method(c.ptr(), "add_point", closest_seg_point, Vector3(), Vector3(), closest_seg + 1);
+				ur->add_undo_method(c.ptr(), "remove_point", closest_seg + 1);
 				ur->commit_action();
 				return true;
 
 			} else {
 
 				Vector3 org;
-				if (c->get_point_count()==0)
-					org=path->get_transform().get_origin();
+				if (c->get_point_count() == 0)
+					org = path->get_transform().get_origin();
 				else
-					org=gt.xform(c->get_point_pos(c->get_point_count()));
-				Plane p(org,p_camera->get_transform().basis.get_axis(2));
-				Vector3 ray_from=p_camera->project_ray_origin(mbpos);
-				Vector3 ray_dir=p_camera->project_ray_normal(mbpos);
+					org = gt.xform(c->get_point_pos(c->get_point_count() - 1));
+				Plane p(org, p_camera->get_transform().basis.get_axis(2));
+				Vector3 ray_from = p_camera->project_ray_origin(mbpos);
+				Vector3 ray_dir = p_camera->project_ray_normal(mbpos);
 
 				Vector3 inters;
-				if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+				if (p.intersects_ray(ray_from, ray_dir, &inters)) {
 
 					ur->create_action(TTR("Add Point to Curve"));
-					ur->add_do_method(c.ptr(),"add_point",it.xform(inters),Vector3(),Vector3(),-1);
-					ur->add_undo_method(c.ptr(),"remove_point",c->get_point_count());
+					ur->add_do_method(c.ptr(), "add_point", it.xform(inters), Vector3(), Vector3(), -1);
+					ur->add_undo_method(c.ptr(), "remove_point", c->get_point_count());
 					ur->commit_action();
 					return true;
 				}
@@ -405,9 +381,9 @@ bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEve
 				//add new at pos
 			}
 
-		} else if (mb->is_pressed() && ((mb->get_button_index()==BUTTON_LEFT && curve_del->is_pressed()) || (mb->get_button_index()==BUTTON_RIGHT && curve_edit->is_pressed()))) {
+		} else if (mb->is_pressed() && ((mb->get_button_index() == BUTTON_LEFT && curve_del->is_pressed()) || (mb->get_button_index() == BUTTON_RIGHT && curve_edit->is_pressed()))) {
 
-			for(int i=0;i<c->get_point_count();i++) {
+			for (int i = 0; i < c->get_point_count(); i++) {
 				real_t dist_to_p = p_camera->unproject_position(gt.xform(c->get_point_pos(i))).distance_to(mbpos);
 				real_t dist_to_p_out = p_camera->unproject_position(gt.xform(c->get_point_pos(i) + c->get_point_out(i))).distance_to(mbpos);
 				real_t dist_to_p_in = p_camera->unproject_position(gt.xform(c->get_point_pos(i) + c->get_point_in(i))).distance_to(mbpos);
@@ -418,40 +394,38 @@ bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEve
 
 					UndoRedo *ur = editor->get_undo_redo();
 					ur->create_action(TTR("Remove Path Point"));
-					ur->add_do_method(c.ptr(),"remove_point",i);
-					ur->add_undo_method(c.ptr(),"add_point",c->get_point_pos(i),c->get_point_in(i),c->get_point_out(i),i);
+					ur->add_do_method(c.ptr(), "remove_point", i);
+					ur->add_undo_method(c.ptr(), "add_point", c->get_point_pos(i), c->get_point_in(i), c->get_point_out(i), i);
 					ur->commit_action();
 					return true;
 				} else if (dist_to_p_out < click_dist) {
 
 					UndoRedo *ur = editor->get_undo_redo();
 					ur->create_action(TTR("Remove Out-Control Point"));
-					ur->add_do_method(c.ptr(),"set_point_out",i,Vector3());
-					ur->add_undo_method(c.ptr(),"set_point_out",i,c->get_point_out(i));
+					ur->add_do_method(c.ptr(), "set_point_out", i, Vector3());
+					ur->add_undo_method(c.ptr(), "set_point_out", i, c->get_point_out(i));
 					ur->commit_action();
 					return true;
 				} else if (dist_to_p_in < click_dist) {
 
 					UndoRedo *ur = editor->get_undo_redo();
 					ur->create_action(TTR("Remove In-Control Point"));
-					ur->add_do_method(c.ptr(),"set_point_in",i,Vector3());
-					ur->add_undo_method(c.ptr(),"set_point_in",i,c->get_point_in(i));
+					ur->add_do_method(c.ptr(), "set_point_in", i, Vector3());
+					ur->add_undo_method(c.ptr(), "set_point_in", i, c->get_point_in(i));
 					ur->commit_action();
 					return true;
 				}
 			}
 		}
-
 	}
 
 	return false;
 }
 
-
 void PathEditorPlugin::edit(Object *p_object) {
 
 	if (p_object) {
-		path=p_object->cast_to<Path>();
+		path = p_object->cast_to<Path>();
 		if (path) {
 
 			if (path->get_curve().is_valid()) {
@@ -459,8 +433,8 @@ void PathEditorPlugin::edit(Object *p_object) {
 			}
 		}
 	} else {
-		Path *pre=path;
-		path=NULL;
+		Path *pre = path;
+		path = NULL;
 		if (pre) {
 			pre->get_curve()->emit_signal("changed");
 		}
@@ -470,7 +444,7 @@ void PathEditorPlugin::edit(Object *p_object) {
 
 bool PathEditorPlugin::handles(Object *p_object) const {
 
-	return p_object->is_type("Path");
+	return p_object->is_class("Path");
 }
 
 void PathEditorPlugin::make_visible(bool p_visible) {
@@ -480,120 +454,115 @@ void PathEditorPlugin::make_visible(bool p_visible) {
 		curve_create->show();
 		curve_edit->show();
 		curve_del->show();
-        curve_close->show();
-        sep->show();
+		curve_close->show();
+		sep->show();
 	} else {
 
 		curve_create->hide();
 		curve_edit->hide();
 		curve_del->hide();
-        curve_close->hide();
-        sep->hide();
+		curve_close->hide();
+		sep->hide();
 
 		{
-			Path *pre=path;
-			path=NULL;
+			Path *pre = path;
+			path = NULL;
 			if (pre && pre->get_curve().is_valid()) {
 				pre->get_curve()->emit_signal("changed");
 			}
 		}
 	}
-
 }
 
 void PathEditorPlugin::_mode_changed(int p_idx) {
 
-	curve_create->set_pressed(p_idx==0);
-	curve_edit->set_pressed(p_idx==1);
-	curve_del->set_pressed(p_idx==2);
+	curve_create->set_pressed(p_idx == 0);
+	curve_edit->set_pressed(p_idx == 1);
+	curve_del->set_pressed(p_idx == 2);
 }
 
 void PathEditorPlugin::_close_curve() {
 
-    Ref<Curve3D> c = path->get_curve();
-    if (c.is_null())
-        return ;
-    if (c->get_point_count()<2)
-        return;
-    c->add_point(c->get_point_pos(0),c->get_point_in(0),c->get_point_out(0));
-
+	Ref<Curve3D> c = path->get_curve();
+	if (c.is_null())
+		return;
+	if (c->get_point_count() < 2)
+		return;
+	c->add_point(c->get_point_pos(0), c->get_point_in(0), c->get_point_out(0));
 }
 
 void PathEditorPlugin::_notification(int p_what) {
 
-	if (p_what==NOTIFICATION_ENTER_TREE) {
+	if (p_what == NOTIFICATION_ENTER_TREE) {
 
-		curve_create->connect("pressed",this,"_mode_changed",make_binds(0));
-		curve_edit->connect("pressed",this,"_mode_changed",make_binds(1));
-		curve_del->connect("pressed",this,"_mode_changed",make_binds(2));
-        curve_close->connect("pressed",this,"_close_curve");
-    }
+		curve_create->connect("pressed", this, "_mode_changed", make_binds(0));
+		curve_edit->connect("pressed", this, "_mode_changed", make_binds(1));
+		curve_del->connect("pressed", this, "_mode_changed", make_binds(2));
+		curve_close->connect("pressed", this, "_close_curve");
+	}
 }
 
 void PathEditorPlugin::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("_mode_changed"),&PathEditorPlugin::_mode_changed);
-    ClassDB::bind_method(D_METHOD("_close_curve"),&PathEditorPlugin::_close_curve);
+	ClassDB::bind_method(D_METHOD("_mode_changed"), &PathEditorPlugin::_mode_changed);
+	ClassDB::bind_method(D_METHOD("_close_curve"), &PathEditorPlugin::_close_curve);
 }
 
-PathEditorPlugin* PathEditorPlugin::singleton=NULL;
-
+PathEditorPlugin *PathEditorPlugin::singleton = NULL;
 
 PathEditorPlugin::PathEditorPlugin(EditorNode *p_node) {
 
-	path=NULL;
-	editor=p_node;
-	singleton=this;
+	path = NULL;
+	editor = p_node;
+	singleton = this;
 
-	path_material = Ref<SpatialMaterial>( memnew( SpatialMaterial ));
-	path_material->set_parameter( SpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.8) );
-	path_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true);
+	path_material = Ref<SpatialMaterial>(memnew(SpatialMaterial));
+	path_material->set_albedo(Color(0.5, 0.5, 1.0, 0.8));
+	path_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
 	path_material->set_line_width(3);
-	path_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
-	path_material->set_flag(Material::FLAG_UNSHADED,true);
+	path_material->set_cull_mode(SpatialMaterial::CULL_DISABLED);
+	path_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
 
-	path_thin_material = Ref<SpatialMaterial>( memnew( SpatialMaterial ));
-	path_thin_material->set_parameter( SpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.4) );
-	path_thin_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true);
+	path_thin_material = Ref<SpatialMaterial>(memnew(SpatialMaterial));
+	path_thin_material->set_albedo(Color(0.5, 0.5, 1.0, 0.4));
+	path_thin_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
 	path_thin_material->set_line_width(1);
-	path_thin_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
-	path_thin_material->set_flag(Material::FLAG_UNSHADED,true);
+	path_thin_material->set_cull_mode(SpatialMaterial::CULL_DISABLED);
+	path_thin_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
 
 	//SpatialEditor::get_singleton()->add_gizmo_plugin(this);
 
-	sep = memnew( VSeparator);
+	sep = memnew(VSeparator);
 	sep->hide();
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(sep);
-	curve_edit = memnew( ToolButton );
-	curve_edit->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveEdit","EditorIcons"));
+	curve_edit = memnew(ToolButton);
+	curve_edit->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveEdit", "EditorIcons"));
 	curve_edit->set_toggle_mode(true);
 	curve_edit->hide();
 	curve_edit->set_focus_mode(Control::FOCUS_NONE);
-	curve_edit->set_tooltip(TTR("Select Points")+"\n"+TTR("Shift+Drag: Select Control Points")+"\n"+keycode_get_string(KEY_MASK_CMD)+TTR("Click: Add Point")+"\n"+TTR("Right Click: Delete Point"));
+	curve_edit->set_tooltip(TTR("Select Points") + "\n" + TTR("Shift+Drag: Select Control Points") + "\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Click: Add Point") + "\n" + TTR("Right Click: Delete Point"));
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_edit);
-	curve_create = memnew( ToolButton );
-	curve_create->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveCreate","EditorIcons"));
+	curve_create = memnew(ToolButton);
+	curve_create->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveCreate", "EditorIcons"));
 	curve_create->set_toggle_mode(true);
 	curve_create->hide();
 	curve_create->set_focus_mode(Control::FOCUS_NONE);
-	curve_create->set_tooltip(TTR("Add Point (in empty space)")+"\n"+TTR("Split Segment (in curve)"));
+	curve_create->set_tooltip(TTR("Add Point (in empty space)") + "\n" + TTR("Split Segment (in curve)"));
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_create);
-	curve_del = memnew( ToolButton );
-	curve_del->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveDelete","EditorIcons"));
+	curve_del = memnew(ToolButton);
+	curve_del->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveDelete", "EditorIcons"));
 	curve_del->set_toggle_mode(true);
 	curve_del->hide();
 	curve_del->set_focus_mode(Control::FOCUS_NONE);
 	curve_del->set_tooltip(TTR("Delete Point"));
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_del);
-	curve_close = memnew( ToolButton );
-	curve_close->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveClose","EditorIcons"));
+	curve_close = memnew(ToolButton);
+	curve_close->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("CurveClose", "EditorIcons"));
 	curve_close->hide();
 	curve_close->set_focus_mode(Control::FOCUS_NONE);
 	curve_close->set_tooltip(TTR("Close Curve"));
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_close);
 
-
-
 	curve_edit->set_pressed(true);
 	/*
 	collision_polygon_editor = memnew( PathEditor(p_node) );
@@ -607,13 +576,7 @@ PathEditorPlugin::PathEditorPlugin(EditorNode *p_node) {
 
 	collision_polygon_editor->hide();
 	*/
-
-
 }
 
-
-PathEditorPlugin::~PathEditorPlugin()
-{
+PathEditorPlugin::~PathEditorPlugin() {
 }
-
-#endif

editor/plugins/path_editor_plugin.h

@@ -32,30 +32,27 @@
 
 #include "editor/spatial_editor_gizmos.h"
 #include "scene/3d/path.h"
-#if 0
-class PathSpatialGizmo  : public EditorSpatialGizmo {
 
-	GDCLASS(PathSpatialGizmo,EditorSpatialGizmo);
+class PathSpatialGizmo : public EditorSpatialGizmo {
 
-	Path* path;
+	GDCLASS(PathSpatialGizmo, EditorSpatialGizmo);
+
+	Path *path;
 	mutable Vector3 original;
 
 public:
-
 	virtual String get_handle_name(int p_idx) const;
 	virtual Variant get_handle_value(int p_idx) const;
-	virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
-	virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
+	virtual void set_handle(int p_idx, Camera *p_camera, const Point2 &p_point);
+	virtual void commit_handle(int p_idx, const Variant &p_restore, bool p_cancel = false);
 
 	void redraw();
-	PathSpatialGizmo(Path* p_path=NULL);
-
+	PathSpatialGizmo(Path *p_path = NULL);
 };
 
 class PathEditorPlugin : public EditorPlugin {
 
-	GDCLASS( PathEditorPlugin, EditorPlugin );
-
+	GDCLASS(PathEditorPlugin, EditorPlugin);
 
 	Separator *sep;
 	ToolButton *curve_create;
@@ -65,26 +62,25 @@ class PathEditorPlugin : public EditorPlugin {
 
 	EditorNode *editor;
 
-
 	Path *path;
 
 	void _mode_changed(int p_idx);
-    void _close_curve();
+	void _close_curve();
+
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
 
 public:
-
 	Path *get_edited_path() { return path; }
 
-	static PathEditorPlugin* singleton;
+	static PathEditorPlugin *singleton;
 	Ref<SpatialMaterial> path_material;
 	Ref<SpatialMaterial> path_thin_material;
-	virtual bool forward_spatial_gui_input(Camera* p_camera,const InputEvent& p_event);
+	virtual bool forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event);
 
 	//virtual bool forward_gui_input(const InputEvent& p_event) { return collision_polygon_editor->forward_gui_input(p_event); }
-	virtual Ref<SpatialEditorGizmo> create_spatial_gizmo(Spatial* p_spatial);
+	virtual Ref<SpatialEditorGizmo> create_spatial_gizmo(Spatial *p_spatial);
 	virtual String get_name() const { return "Path"; }
 	bool has_main_screen() const { return false; }
 	virtual void edit(Object *p_node);
@@ -93,8 +89,6 @@ public:
 
 	PathEditorPlugin(EditorNode *p_node);
 	~PathEditorPlugin();
-
 };
 
-#endif
 #endif // PATH_EDITOR_PLUGIN_H