Merge pull request #57627 from JFonS/occluder_improvements

5 files changed, 311 insertions, 58 deletions

diff --git a/editor/plugins/node_3d_editor_gizmos.cpp b/editor/plugins/node_3d_editor_gizmos.cpp
index 88d2aee667..b4b1cf05ac 100644
--- a/editor/plugins/node_3d_editor_gizmos.cpp
+++ b/editor/plugins/node_3d_editor_gizmos.cpp
@@ -1889,6 +1889,7 @@ void MeshInstance3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
 
 OccluderInstance3DGizmoPlugin::OccluderInstance3DGizmoPlugin() {
 	create_material("line_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/occluder", Color(0.8, 0.5, 1)));
+	create_handle_material("handles");
 }
 
 bool OccluderInstance3DGizmoPlugin::has_gizmo(Node3D *p_spatial) {
@@ -1903,6 +1904,189 @@ int OccluderInstance3DGizmoPlugin::get_priority() const {
 	return -1;
 }
 
+String OccluderInstance3DGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const {
+	const OccluderInstance3D *cs = Object::cast_to<OccluderInstance3D>(p_gizmo->get_spatial_node());
+
+	Ref<Occluder3D> o = cs->get_occluder();
+	if (o.is_null()) {
+		return "";
+	}
+
+	if (Object::cast_to<SphereOccluder3D>(*o)) {
+		return "Radius";
+	}
+
+	if (Object::cast_to<BoxOccluder3D>(*o) || Object::cast_to<QuadOccluder3D>(*o)) {
+		return "Size";
+	}
+
+	return "";
+}
+
+Variant OccluderInstance3DGizmoPlugin::get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const {
+	OccluderInstance3D *oi = Object::cast_to<OccluderInstance3D>(p_gizmo->get_spatial_node());
+
+	Ref<Occluder3D> o = oi->get_occluder();
+	if (o.is_null()) {
+		return Variant();
+	}
+
+	if (Object::cast_to<SphereOccluder3D>(*o)) {
+		Ref<SphereOccluder3D> so = o;
+		return so->get_radius();
+	}
+
+	if (Object::cast_to<BoxOccluder3D>(*o)) {
+		Ref<BoxOccluder3D> bo = o;
+		return bo->get_size();
+	}
+
+	if (Object::cast_to<QuadOccluder3D>(*o)) {
+		Ref<QuadOccluder3D> qo = o;
+		return qo->get_size();
+	}
+
+	return Variant();
+}
+
+void OccluderInstance3DGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, Camera3D *p_camera, const Point2 &p_point) {
+	OccluderInstance3D *oi = Object::cast_to<OccluderInstance3D>(p_gizmo->get_spatial_node());
+
+	Ref<Occluder3D> o = oi->get_occluder();
+	if (o.is_null()) {
+		return;
+	}
+
+	Transform3D gt = oi->get_global_transform();
+	Transform3D gi = gt.affine_inverse();
+
+	Vector3 ray_from = p_camera->project_ray_origin(p_point);
+	Vector3 ray_dir = p_camera->project_ray_normal(p_point);
+
+	Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
+
+	bool snap_enabled = Node3DEditor::get_singleton()->is_snap_enabled();
+	float snap = Node3DEditor::get_singleton()->get_translate_snap();
+
+	if (Object::cast_to<SphereOccluder3D>(*o)) {
+		Ref<SphereOccluder3D> so = o;
+		Vector3 ra, rb;
+		Geometry3D::get_closest_points_between_segments(Vector3(), Vector3(4096, 0, 0), sg[0], sg[1], ra, rb);
+		float d = ra.x;
+		if (snap_enabled) {
+			d = Math::snapped(d, snap);
+		}
+
+		if (d < 0.001) {
+			d = 0.001;
+		}
+
+		so->set_radius(d);
+	}
+
+	if (Object::cast_to<BoxOccluder3D>(*o)) {
+		Vector3 axis;
+		axis[p_id] = 1.0;
+		Ref<BoxOccluder3D> bo = o;
+		Vector3 ra, rb;
+		Geometry3D::get_closest_points_between_segments(Vector3(), axis * 4096, sg[0], sg[1], ra, rb);
+		float d = ra[p_id];
+		if (snap_enabled) {
+			d = Math::snapped(d, snap);
+		}
+
+		if (d < 0.001) {
+			d = 0.001;
+		}
+
+		Vector3 he = bo->get_size();
+		he[p_id] = d * 2;
+		bo->set_size(he);
+	}
+
+	if (Object::cast_to<QuadOccluder3D>(*o)) {
+		Ref<QuadOccluder3D> qo = o;
+		Plane p = Plane(Vector3(0.0f, 0.0f, 1.0f), 0.0f);
+		Vector3 intersection;
+		if (!p.intersects_segment(sg[0], sg[1], &intersection)) {
+			return;
+		}
+
+		if (p_id == 2) {
+			Vector2 s = Vector2(intersection.x, intersection.y) * 2.0f;
+			if (snap_enabled) {
+				s = s.snapped(Vector2(snap, snap));
+			}
+			s = s.max(Vector2(0.001, 0.001));
+			qo->set_size(s);
+		} else {
+			float d = intersection[p_id];
+			if (snap_enabled) {
+				d = Math::snapped(d, snap);
+			}
+
+			if (d < 0.001) {
+				d = 0.001;
+			}
+
+			Vector2 he = qo->get_size();
+			he[p_id] = d * 2.0f;
+			qo->set_size(he);
+		}
+	}
+}
+
+void OccluderInstance3DGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, const Variant &p_restore, bool p_cancel) {
+	OccluderInstance3D *oi = Object::cast_to<OccluderInstance3D>(p_gizmo->get_spatial_node());
+
+	Ref<Occluder3D> o = oi->get_occluder();
+	if (o.is_null()) {
+		return;
+	}
+
+	if (Object::cast_to<SphereOccluder3D>(*o)) {
+		Ref<SphereOccluder3D> so = o;
+		if (p_cancel) {
+			so->set_radius(p_restore);
+			return;
+		}
+
+		UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
+		ur->create_action(TTR("Change Sphere Shape Radius"));
+		ur->add_do_method(so.ptr(), "set_radius", so->get_radius());
+		ur->add_undo_method(so.ptr(), "set_radius", p_restore);
+		ur->commit_action();
+	}
+
+	if (Object::cast_to<BoxOccluder3D>(*o)) {
+		Ref<BoxOccluder3D> bo = o;
+		if (p_cancel) {
+			bo->set_size(p_restore);
+			return;
+		}
+
+		UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
+		ur->create_action(TTR("Change Box Shape Size"));
+		ur->add_do_method(bo.ptr(), "set_size", bo->get_size());
+		ur->add_undo_method(bo.ptr(), "set_size", p_restore);
+		ur->commit_action();
+	}
+
+	if (Object::cast_to<QuadOccluder3D>(*o)) {
+		Ref<QuadOccluder3D> qo = o;
+		if (p_cancel) {
+			qo->set_size(p_restore);
+			return;
+		}
+
+		UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
+		ur->create_action(TTR("Change Box Shape Size"));
+		ur->add_do_method(qo.ptr(), "set_size", qo->get_size());
+		ur->add_undo_method(qo.ptr(), "set_size", p_restore);
+		ur->commit_action();
+	}
+}
+
 void OccluderInstance3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
 	OccluderInstance3D *occluder_instance = Object::cast_to<OccluderInstance3D>(p_gizmo->get_spatial_node());
 
@@ -1920,6 +2104,35 @@ void OccluderInstance3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
 		p_gizmo->add_lines(lines, material);
 		p_gizmo->add_collision_segments(lines);
 	}
+
+	Ref<Material> handles_material = get_material("handles");
+	if (Object::cast_to<SphereOccluder3D>(*o)) {
+		Ref<SphereOccluder3D> so = o;
+		float r = so->get_radius();
+		Vector<Vector3> handles = { Vector3(r, 0, 0) };
+		p_gizmo->add_handles(handles, handles_material);
+	}
+
+	if (Object::cast_to<BoxOccluder3D>(*o)) {
+		Ref<BoxOccluder3D> bo = o;
+
+		Vector<Vector3> handles;
+		for (int i = 0; i < 3; i++) {
+			Vector3 ax;
+			ax[i] = bo->get_size()[i] / 2;
+			handles.push_back(ax);
+		}
+
+		p_gizmo->add_handles(handles, handles_material);
+	}
+
+	if (Object::cast_to<QuadOccluder3D>(*o)) {
+		Ref<QuadOccluder3D> qo = o;
+		Vector2 size = qo->get_size();
+		Vector3 s = Vector3(size.x, size.y, 0.0f) / 2.0f;
+		Vector<Vector3> handles = { Vector3(s.x, 0.0f, 0.0f), Vector3(0.0f, s.y, 0.0f), Vector3(s.x, s.y, 0.0f) };
+		p_gizmo->add_handles(handles, handles_material);
+	}
 }
 
 /////
diff --git a/editor/plugins/node_3d_editor_gizmos.h b/editor/plugins/node_3d_editor_gizmos.h
index 66b3f02fcf..fa55651d26 100644
--- a/editor/plugins/node_3d_editor_gizmos.h
+++ b/editor/plugins/node_3d_editor_gizmos.h
@@ -300,6 +300,11 @@ public:
 	int get_priority() const override;
 	void redraw(EditorNode3DGizmo *p_gizmo) override;
 
+	String get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const override;
+	Variant get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const override;
+	void set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, Camera3D *p_camera, const Point2 &p_point) override;
+	void commit_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, const Variant &p_restore, bool p_cancel = false) override;
+
 	OccluderInstance3DGizmoPlugin();
 };
 
diff --git a/editor/plugins/occluder_instance_3d_editor_plugin.cpp b/editor/plugins/occluder_instance_3d_editor_plugin.cpp
index 2dd760275e..e7fe8da716 100644
--- a/editor/plugins/occluder_instance_3d_editor_plugin.cpp
+++ b/editor/plugins/occluder_instance_3d_editor_plugin.cpp
@@ -34,9 +34,9 @@ void OccluderInstance3DEditorPlugin::_bake_select_file(const String &p_file) {
 	if (occluder_instance) {
 		OccluderInstance3D::BakeError err;
 		if (get_tree()->get_edited_scene_root() && get_tree()->get_edited_scene_root() == occluder_instance) {
-			err = occluder_instance->bake(occluder_instance, p_file);
+			err = occluder_instance->bake_scene(occluder_instance, p_file);
 		} else {
-			err = occluder_instance->bake(occluder_instance->get_parent(), p_file);
+			err = occluder_instance->bake_scene(occluder_instance->get_parent(), p_file);
 		}
 
 		switch (err) {
@@ -59,6 +59,10 @@ void OccluderInstance3DEditorPlugin::_bake_select_file(const String &p_file) {
 				EditorNode::get_singleton()->show_warning(TTR("No meshes to bake.\nMake sure there is at least one MeshInstance3D node in the scene whose visual layers are part of the OccluderInstance3D's Bake Mask property."));
 				break;
 			}
+			case OccluderInstance3D::BAKE_ERROR_CANT_SAVE: {
+				EditorNode::get_singleton()->show_warning(TTR("Could not save the new occluder at the specified path: ") + p_file);
+				break;
+			}
 			default: {
 			}
 		}
diff --git a/editor/plugins/collision_polygon_3d_editor_plugin.cpp b/editor/plugins/polygon_3d_editor_plugin.cpp
index 52651ae380..4014da2441 100644
--- a/editor/plugins/collision_polygon_3d_editor_plugin.cpp
+++ b/editor/plugins/polygon_3d_editor_plugin.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  collision_polygon_3d_editor_plugin.cpp                               */
+/*  polygon_3d_editor_plugin.cpp                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,9 +28,10 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "collision_polygon_3d_editor_plugin.h"
+#include "polygon_3d_editor_plugin.h"
 
 #include "canvas_item_editor_plugin.h"
+#include "core/core_string_names.h"
 #include "core/input/input.h"
 #include "core/io/file_access.h"
 #include "core/math/geometry_2d.h"
@@ -39,13 +40,13 @@
 #include "node_3d_editor_plugin.h"
 #include "scene/3d/camera_3d.h"
 
-void CollisionPolygon3DEditor::_notification(int p_what) {
+void Polygon3DEditor::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_READY: {
 			button_create->set_icon(get_theme_icon(SNAME("Edit"), SNAME("EditorIcons")));
 			button_edit->set_icon(get_theme_icon(SNAME("MovePoint"), SNAME("EditorIcons")));
 			button_edit->set_pressed(true);
-			get_tree()->connect("node_removed", callable_mp(this, &CollisionPolygon3DEditor::_node_removed));
+			get_tree()->connect("node_removed", callable_mp(this, &Polygon3DEditor::_node_removed));
 
 		} break;
 		case NOTIFICATION_PROCESS: {
@@ -62,7 +63,7 @@ void CollisionPolygon3DEditor::_notification(int p_what) {
 	}
 }
 
-void CollisionPolygon3DEditor::_node_removed(Node *p_node) {
+void Polygon3DEditor::_node_removed(Node *p_node) {
 	if (p_node == node) {
 		node = nullptr;
 		if (imgeom->get_parent() == p_node) {
@@ -73,7 +74,7 @@ void CollisionPolygon3DEditor::_node_removed(Node *p_node) {
 	}
 }
 
-void CollisionPolygon3DEditor::_menu_option(int p_option) {
+void Polygon3DEditor::_menu_option(int p_option) {
 	switch (p_option) {
 		case MODE_CREATE: {
 			mode = MODE_CREATE;
@@ -88,10 +89,12 @@ void CollisionPolygon3DEditor::_menu_option(int p_option) {
 	}
 }
 
-void CollisionPolygon3DEditor::_wip_close() {
+void Polygon3DEditor::_wip_close() {
+	Object *obj = node_resource.is_valid() ? (Object *)node_resource.ptr() : node;
+	ERR_FAIL_COND_MSG(!obj, "Edited object is not valid.");
 	undo_redo->create_action(TTR("Create Polygon3D"));
-	undo_redo->add_undo_method(node, "set_polygon", node->call("get_polygon"));
-	undo_redo->add_do_method(node, "set_polygon", wip);
+	undo_redo->add_undo_method(obj, "set_polygon", obj->call("get_polygon"));
+	undo_redo->add_do_method(obj, "set_polygon", wip);
 	undo_redo->add_do_method(this, "_polygon_draw");
 	undo_redo->add_undo_method(this, "_polygon_draw");
 	wip.clear();
@@ -103,11 +106,12 @@ void CollisionPolygon3DEditor::_wip_close() {
 	undo_redo->commit_action();
 }
 
-EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(Camera3D *p_camera, const Ref<InputEvent> &p_event) {
+EditorPlugin::AfterGUIInput Polygon3DEditor::forward_spatial_gui_input(Camera3D *p_camera, const Ref<InputEvent> &p_event) {
 	if (!node) {
 		return EditorPlugin::AFTER_GUI_INPUT_PASS;
 	}
 
+	Object *obj = node_resource.is_valid() ? (Object *)node_resource.ptr() : node;
 	Transform3D gt = node->get_global_transform();
 	Transform3D gi = gt.affine_inverse();
 	float depth = _get_depth() * 0.5;
@@ -135,7 +139,7 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 		//Let the snap happen when the point is being moved, instead.
 		//cpoint = CanvasItemEditor::get_singleton()->snap_point(cpoint);
 
-		Vector<Vector2> poly = node->call("get_polygon");
+		PackedVector2Array poly = _get_polygon();
 
 		//first check if a point is to be added (segment split)
 		real_t grab_threshold = EDITOR_GET("editors/polygon_editor/point_grab_radius");
@@ -178,9 +182,9 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 						if (mb->is_ctrl_pressed()) {
 							if (poly.size() < 3) {
 								undo_redo->create_action(TTR("Edit Poly"));
-								undo_redo->add_undo_method(node, "set_polygon", poly);
+								undo_redo->add_undo_method(obj, "set_polygon", poly);
 								poly.push_back(cpoint);
-								undo_redo->add_do_method(node, "set_polygon", poly);
+								undo_redo->add_do_method(obj, "set_polygon", poly);
 								undo_redo->add_do_method(this, "_polygon_draw");
 								undo_redo->add_undo_method(this, "_polygon_draw");
 								undo_redo->commit_action();
@@ -215,7 +219,7 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 								poly.insert(closest_idx + 1, cpoint);
 								edited_point = closest_idx + 1;
 								edited_point_pos = cpoint;
-								node->call("set_polygon", poly);
+								_set_polygon(poly);
 								_polygon_draw();
 								snap_ignore = true;
 
@@ -256,8 +260,8 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 							ERR_FAIL_INDEX_V(edited_point, poly.size(), EditorPlugin::AFTER_GUI_INPUT_PASS);
 							poly.write[edited_point] = edited_point_pos;
 							undo_redo->create_action(TTR("Edit Poly"));
-							undo_redo->add_do_method(node, "set_polygon", poly);
-							undo_redo->add_undo_method(node, "set_polygon", pre_move_edit);
+							undo_redo->add_do_method(obj, "set_polygon", poly);
+							undo_redo->add_undo_method(obj, "set_polygon", pre_move_edit);
 							undo_redo->add_do_method(this, "_polygon_draw");
 							undo_redo->add_undo_method(this, "_polygon_draw");
 							undo_redo->commit_action();
@@ -284,9 +288,9 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 
 					if (closest_idx >= 0) {
 						undo_redo->create_action(TTR("Edit Poly (Remove Point)"));
-						undo_redo->add_undo_method(node, "set_polygon", poly);
+						undo_redo->add_undo_method(obj, "set_polygon", poly);
 						poly.remove_at(closest_idx);
-						undo_redo->add_do_method(node, "set_polygon", poly);
+						undo_redo->add_do_method(obj, "set_polygon", poly);
 						undo_redo->add_do_method(this, "_polygon_draw");
 						undo_redo->add_undo_method(this, "_polygon_draw");
 						undo_redo->commit_action();
@@ -335,25 +339,40 @@ EditorPlugin::AfterGUIInput CollisionPolygon3DEditor::forward_spatial_gui_input(
 	return EditorPlugin::AFTER_GUI_INPUT_PASS;
 }
 
-float CollisionPolygon3DEditor::_get_depth() {
-	if (bool(node->call("_has_editable_3d_polygon_no_depth"))) {
-		return 0;
+float Polygon3DEditor::_get_depth() {
+	Object *obj = node_resource.is_valid() ? (Object *)node_resource.ptr() : node;
+	ERR_FAIL_COND_V_MSG(!obj, 0.0f, "Edited object is not valid.");
+
+	if (bool(obj->call("_has_editable_3d_polygon_no_depth"))) {
+		return 0.0f;
 	}
 
-	return float(node->call("get_depth"));
+	return float(obj->call("get_depth"));
+}
+
+PackedVector2Array Polygon3DEditor::_get_polygon() {
+	Object *obj = node_resource.is_valid() ? (Object *)node_resource.ptr() : node;
+	ERR_FAIL_COND_V_MSG(!obj, PackedVector2Array(), "Edited object is not valid.");
+	return PackedVector2Array(obj->call("get_polygon"));
+}
+
+void Polygon3DEditor::_set_polygon(PackedVector2Array p_poly) {
+	Object *obj = node_resource.is_valid() ? (Object *)node_resource.ptr() : node;
+	ERR_FAIL_COND_MSG(!obj, "Edited object is not valid.");
+	obj->call("set_polygon", p_poly);
 }
 
-void CollisionPolygon3DEditor::_polygon_draw() {
+void Polygon3DEditor::_polygon_draw() {
 	if (!node) {
 		return;
 	}
 
-	Vector<Vector2> poly;
+	PackedVector2Array poly;
 
 	if (wip_active) {
 		poly = wip;
 	} else {
-		poly = node->call("get_polygon");
+		poly = _get_polygon();
 	}
 
 	float depth = _get_depth() * 0.5;
@@ -464,23 +483,32 @@ void CollisionPolygon3DEditor::_polygon_draw() {
 	m->surface_set_material(0, handle_material);
 }
 
-void CollisionPolygon3DEditor::edit(Node *p_collision_polygon) {
-	if (p_collision_polygon) {
-		node = Object::cast_to<Node3D>(p_collision_polygon);
+void Polygon3DEditor::edit(Node *p_node) {
+	if (p_node) {
+		node = Object::cast_to<Node3D>(p_node);
+		node_resource = node->call("_get_editable_3d_polygon_resource");
+
+		if (node_resource.is_valid()) {
+			node_resource->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Polygon3DEditor::_polygon_draw));
+		}
 		//Enable the pencil tool if the polygon is empty
-		if (Vector<Vector2>(node->call("get_polygon")).size() == 0) {
+		if (_get_polygon().is_empty()) {
 			_menu_option(MODE_CREATE);
 		}
 		wip.clear();
 		wip_active = false;
 		edited_point = -1;
-		p_collision_polygon->add_child(imgeom);
+		p_node->add_child(imgeom);
 		_polygon_draw();
 		set_process(true);
 		prev_depth = -1;
 
 	} else {
 		node = nullptr;
+		if (node_resource.is_valid()) {
+			node_resource->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Polygon3DEditor::_polygon_draw));
+		}
+		node_resource.unref();
 
 		if (imgeom->get_parent()) {
 			imgeom->get_parent()->remove_child(imgeom);
@@ -490,11 +518,11 @@ void CollisionPolygon3DEditor::edit(Node *p_collision_polygon) {
 	}
 }
 
-void CollisionPolygon3DEditor::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("_polygon_draw"), &CollisionPolygon3DEditor::_polygon_draw);
+void Polygon3DEditor::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("_polygon_draw"), &Polygon3DEditor::_polygon_draw);
 }
 
-CollisionPolygon3DEditor::CollisionPolygon3DEditor(EditorNode *p_editor) {
+Polygon3DEditor::Polygon3DEditor(EditorNode *p_editor) {
 	node = nullptr;
 	editor = p_editor;
 	undo_redo = EditorNode::get_undo_redo();
@@ -503,13 +531,13 @@ CollisionPolygon3DEditor::CollisionPolygon3DEditor(EditorNode *p_editor) {
 	button_create = memnew(Button);
 	button_create->set_flat(true);
 	add_child(button_create);
-	button_create->connect("pressed", callable_mp(this, &CollisionPolygon3DEditor::_menu_option), varray(MODE_CREATE));
+	button_create->connect("pressed", callable_mp(this, &Polygon3DEditor::_menu_option), varray(MODE_CREATE));
 	button_create->set_toggle_mode(true);
 
 	button_edit = memnew(Button);
 	button_edit->set_flat(true);
 	add_child(button_edit);
-	button_edit->connect("pressed", callable_mp(this, &CollisionPolygon3DEditor::_menu_option), varray(MODE_EDIT));
+	button_edit->connect("pressed", callable_mp(this, &Polygon3DEditor::_menu_option), varray(MODE_EDIT));
 	button_edit->set_toggle_mode(true);
 
 	mode = MODE_EDIT;
@@ -545,12 +573,12 @@ CollisionPolygon3DEditor::CollisionPolygon3DEditor(EditorNode *p_editor) {
 	snap_ignore = false;
 }
 
-CollisionPolygon3DEditor::~CollisionPolygon3DEditor() {
+Polygon3DEditor::~Polygon3DEditor() {
 	memdelete(imgeom);
 }
 
 void Polygon3DEditorPlugin::edit(Object *p_object) {
-	collision_polygon_editor->edit(Object::cast_to<Node>(p_object));
+	polygon_editor->edit(Object::cast_to<Node>(p_object));
 }
 
 bool Polygon3DEditorPlugin::handles(Object *p_object) const {
@@ -559,19 +587,19 @@ bool Polygon3DEditorPlugin::handles(Object *p_object) const {
 
 void Polygon3DEditorPlugin::make_visible(bool p_visible) {
 	if (p_visible) {
-		collision_polygon_editor->show();
+		polygon_editor->show();
 	} else {
-		collision_polygon_editor->hide();
-		collision_polygon_editor->edit(nullptr);
+		polygon_editor->hide();
+		polygon_editor->edit(nullptr);
 	}
 }
 
 Polygon3DEditorPlugin::Polygon3DEditorPlugin(EditorNode *p_node) {
 	editor = p_node;
-	collision_polygon_editor = memnew(CollisionPolygon3DEditor(p_node));
-	Node3DEditor::get_singleton()->add_control_to_menu_panel(collision_polygon_editor);
+	polygon_editor = memnew(Polygon3DEditor(p_node));
+	Node3DEditor::get_singleton()->add_control_to_menu_panel(polygon_editor);
 
-	collision_polygon_editor->hide();
+	polygon_editor->hide();
 }
 
 Polygon3DEditorPlugin::~Polygon3DEditorPlugin() {
diff --git a/editor/plugins/collision_polygon_3d_editor_plugin.h b/editor/plugins/polygon_3d_editor_plugin.h
index cd8c857398..6b0370541e 100644
--- a/editor/plugins/collision_polygon_3d_editor_plugin.h
+++ b/editor/plugins/polygon_3d_editor_plugin.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  collision_polygon_3d_editor_plugin.h                                 */
+/*  polygon_3d_editor_plugin.h                                           */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,8 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef COLLISION_POLYGON_EDITOR_PLUGIN_H
-#define COLLISION_POLYGON_EDITOR_PLUGIN_H
+#ifndef POLYGON_3D_EDITOR_PLUGIN_H
+#define POLYGON_3D_EDITOR_PLUGIN_H
 
 #include "editor/editor_node.h"
 #include "editor/editor_plugin.h"
@@ -39,8 +39,8 @@
 
 class CanvasItemEditor;
 
-class CollisionPolygon3DEditor : public HBoxContainer {
-	GDCLASS(CollisionPolygon3DEditor, HBoxContainer);
+class Polygon3DEditor : public HBoxContainer {
+	GDCLASS(Polygon3DEditor, HBoxContainer);
 
 	UndoRedo *undo_redo;
 	enum Mode {
@@ -60,6 +60,7 @@ class CollisionPolygon3DEditor : public HBoxContainer {
 	EditorNode *editor;
 	Panel *panel;
 	Node3D *node;
+	Ref<Resource> node_resource;
 	Ref<ImmediateMesh> imesh;
 	MeshInstance3D *imgeom;
 	MeshInstance3D *pointsm;
@@ -69,8 +70,8 @@ class CollisionPolygon3DEditor : public HBoxContainer {
 
 	int edited_point;
 	Vector2 edited_point_pos;
-	Vector<Vector2> pre_move_edit;
-	Vector<Vector2> wip;
+	PackedVector2Array pre_move_edit;
+	PackedVector2Array wip;
 	bool wip_active;
 	bool snap_ignore;
 
@@ -81,6 +82,8 @@ class CollisionPolygon3DEditor : public HBoxContainer {
 	void _menu_option(int p_option);
 
 	float _get_depth();
+	PackedVector2Array _get_polygon();
+	void _set_polygon(PackedVector2Array p_poly);
 
 protected:
 	void _notification(int p_what);
@@ -89,19 +92,19 @@ protected:
 
 public:
 	virtual EditorPlugin::AfterGUIInput forward_spatial_gui_input(Camera3D *p_camera, const Ref<InputEvent> &p_event);
-	void edit(Node *p_collision_polygon);
-	CollisionPolygon3DEditor(EditorNode *p_editor);
-	~CollisionPolygon3DEditor();
+	void edit(Node *p_node);
+	Polygon3DEditor(EditorNode *p_editor);
+	~Polygon3DEditor();
 };
 
 class Polygon3DEditorPlugin : public EditorPlugin {
 	GDCLASS(Polygon3DEditorPlugin, EditorPlugin);
 
-	CollisionPolygon3DEditor *collision_polygon_editor;
+	Polygon3DEditor *polygon_editor;
 	EditorNode *editor;
 
 public:
-	virtual EditorPlugin::AfterGUIInput forward_spatial_gui_input(Camera3D *p_camera, const Ref<InputEvent> &p_event) override { return collision_polygon_editor->forward_spatial_gui_input(p_camera, p_event); }
+	virtual EditorPlugin::AfterGUIInput forward_spatial_gui_input(Camera3D *p_camera, const Ref<InputEvent> &p_event) override { return polygon_editor->forward_spatial_gui_input(p_camera, p_event); }
 
 	virtual String get_name() const override { return "Polygon3DEditor"; }
 	bool has_main_screen() const override { return false; }
@@ -113,4 +116,4 @@ public:
 	~Polygon3DEditorPlugin();
 };
 
-#endif // COLLISION_POLYGON_EDITOR_PLUGIN_H
+#endif // POLYGON_3D_EDITOR_PLUGIN_H