1 /*************************************************************************/
2 /* collision_polygon_2d_editor_plugin.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30 #include "collision_polygon_2d_editor_plugin.h"
31
32 #include "canvas_item_editor_plugin.h"
33 #include "editor/editor_settings.h"
34 #include "os/file_access.h"
35
_notification(int p_what)36 void CollisionPolygon2DEditor::_notification(int p_what) {
37
38 switch (p_what) {
39
40 case NOTIFICATION_READY: {
41
42 button_create->set_icon(get_icon("Edit", "EditorIcons"));
43 button_edit->set_icon(get_icon("MovePoint", "EditorIcons"));
44 button_edit->set_pressed(true);
45 get_tree()->connect("node_removed", this, "_node_removed");
46
47 } break;
48 case NOTIFICATION_FIXED_PROCESS: {
49
50 } break;
51 }
52 }
_node_removed(Node * p_node)53 void CollisionPolygon2DEditor::_node_removed(Node *p_node) {
54
55 if (p_node == node) {
56 node = NULL;
57 hide();
58 canvas_item_editor->get_viewport_control()->update();
59 }
60 }
61
_menu_option(int p_option)62 void CollisionPolygon2DEditor::_menu_option(int p_option) {
63
64 switch (p_option) {
65
66 case MODE_CREATE: {
67
68 mode = MODE_CREATE;
69 button_create->set_pressed(true);
70 button_edit->set_pressed(false);
71 } break;
72 case MODE_EDIT: {
73
74 mode = MODE_EDIT;
75 button_create->set_pressed(false);
76 button_edit->set_pressed(true);
77 } break;
78 }
79 }
80
_wip_close()81 void CollisionPolygon2DEditor::_wip_close() {
82
83 undo_redo->create_action(TTR("Create Poly"));
84 undo_redo->add_undo_method(node, "set_polygon", node->get_polygon());
85 undo_redo->add_do_method(node, "set_polygon", wip);
86 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
87 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
88 undo_redo->commit_action();
89 wip.clear();
90 wip_active = false;
91 mode = MODE_EDIT;
92 button_edit->set_pressed(true);
93 button_create->set_pressed(false);
94 edited_point = -1;
95 }
96
forward_input_event(const InputEvent & p_event)97 bool CollisionPolygon2DEditor::forward_input_event(const InputEvent &p_event) {
98
99 if (!node)
100 return false;
101
102 switch (p_event.type) {
103
104 case InputEvent::MOUSE_BUTTON: {
105
106 const InputEventMouseButton &mb = p_event.mouse_button;
107
108 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
109
110 Vector2 gpoint = Point2(mb.x, mb.y);
111 Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
112 cpoint = canvas_item_editor->snap_point(cpoint);
113 cpoint = node->get_global_transform().affine_inverse().xform(cpoint);
114
115 Vector<Vector2> poly = node->get_polygon();
116
117 //first check if a point is to be added (segment split)
118 real_t grab_treshold = EDITOR_DEF("poly_editor/point_grab_radius", 8);
119
120 switch (mode) {
121
122 case MODE_CREATE: {
123
124 if (mb.button_index == BUTTON_LEFT && mb.pressed) {
125
126 if (!wip_active) {
127
128 wip.clear();
129 wip.push_back(cpoint);
130 wip_active = true;
131 edited_point_pos = cpoint;
132 canvas_item_editor->get_viewport_control()->update();
133 edited_point = 1;
134 return true;
135 } else {
136
137 if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) {
138 //wip closed
139 _wip_close();
140
141 return true;
142 } else {
143
144 wip.push_back(cpoint);
145 edited_point = wip.size();
146 canvas_item_editor->get_viewport_control()->update();
147 return true;
148
149 //add wip point
150 }
151 }
152 } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && wip_active) {
153 _wip_close();
154 }
155
156 } break;
157
158 case MODE_EDIT: {
159
160 if (mb.button_index == BUTTON_LEFT) {
161 if (mb.pressed) {
162
163 if (mb.mod.control) {
164
165 if (poly.size() < 3) {
166
167 undo_redo->create_action(TTR("Edit Poly"));
168 undo_redo->add_undo_method(node, "set_polygon", poly);
169 poly.push_back(cpoint);
170 undo_redo->add_do_method(node, "set_polygon", poly);
171 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
172 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
173 undo_redo->commit_action();
174 return true;
175 }
176
177 //search edges
178 int closest_idx = -1;
179 Vector2 closest_pos;
180 real_t closest_dist = 1e10;
181 for (int i = 0; i < poly.size(); i++) {
182
183 Vector2 points[2] = { xform.xform(poly[i]),
184 xform.xform(poly[(i + 1) % poly.size()]) };
185
186 Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points);
187 if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2)
188 continue; //not valid to reuse point
189
190 real_t d = cp.distance_to(gpoint);
191 if (d < closest_dist && d < grab_treshold) {
192 closest_dist = d;
193 closest_pos = cp;
194 closest_idx = i;
195 }
196 }
197
198 if (closest_idx >= 0) {
199
200 pre_move_edit = poly;
201 poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos));
202 edited_point = closest_idx + 1;
203 edited_point_pos = xform.affine_inverse().xform(closest_pos);
204 node->set_polygon(poly);
205 canvas_item_editor->get_viewport_control()->update();
206 return true;
207 }
208 } else {
209
210 //look for points to move
211
212 int closest_idx = -1;
213 Vector2 closest_pos;
214 real_t closest_dist = 1e10;
215 for (int i = 0; i < poly.size(); i++) {
216
217 Vector2 cp = xform.xform(poly[i]);
218
219 real_t d = cp.distance_to(gpoint);
220 if (d < closest_dist && d < grab_treshold) {
221 closest_dist = d;
222 closest_pos = cp;
223 closest_idx = i;
224 }
225 }
226
227 if (closest_idx >= 0) {
228
229 pre_move_edit = poly;
230 edited_point = closest_idx;
231 edited_point_pos = xform.affine_inverse().xform(closest_pos);
232 canvas_item_editor->get_viewport_control()->update();
233 return true;
234 }
235 }
236 } else {
237
238 if (edited_point != -1) {
239
240 //apply
241
242 ERR_FAIL_INDEX_V(edited_point, poly.size(), false);
243 poly[edited_point] = edited_point_pos;
244 undo_redo->create_action(TTR("Edit Poly"));
245 undo_redo->add_do_method(node, "set_polygon", poly);
246 undo_redo->add_undo_method(node, "set_polygon", pre_move_edit);
247 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
248 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
249 undo_redo->commit_action();
250
251 edited_point = -1;
252 return true;
253 }
254 }
255 }
256 if (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) {
257
258 int closest_idx = -1;
259 Vector2 closest_pos;
260 real_t closest_dist = 1e10;
261 for (int i = 0; i < poly.size(); i++) {
262
263 Vector2 cp = xform.xform(poly[i]);
264
265 real_t d = cp.distance_to(gpoint);
266 if (d < closest_dist && d < grab_treshold) {
267 closest_dist = d;
268 closest_pos = cp;
269 closest_idx = i;
270 }
271 }
272
273 if (closest_idx >= 0) {
274
275 undo_redo->create_action(TTR("Edit Poly (Remove Point)"));
276 undo_redo->add_undo_method(node, "set_polygon", poly);
277 poly.remove(closest_idx);
278 undo_redo->add_do_method(node, "set_polygon", poly);
279 undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
280 undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
281 undo_redo->commit_action();
282 return true;
283 }
284 }
285
286 } break;
287 }
288
289 } break;
290 case InputEvent::MOUSE_MOTION: {
291
292 const InputEventMouseMotion &mm = p_event.mouse_motion;
293
294 if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) {
295
296 Vector2 gpoint = Point2(mm.x, mm.y);
297 Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
298 cpoint = canvas_item_editor->snap_point(cpoint);
299 edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint);
300
301 canvas_item_editor->get_viewport_control()->update();
302 }
303
304 } break;
305 }
306
307 return false;
308 }
_canvas_draw()309 void CollisionPolygon2DEditor::_canvas_draw() {
310
311 if (!node)
312 return;
313
314 Control *vpc = canvas_item_editor->get_viewport_control();
315
316 Vector<Vector2> poly;
317
318 if (wip_active)
319 poly = wip;
320 else
321 poly = node->get_polygon();
322
323 Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
324 Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
325
326 for (int i = 0; i < poly.size(); i++) {
327
328 Vector2 p, p2;
329 p = i == edited_point ? edited_point_pos : poly[i];
330 if ((wip_active && i == poly.size() - 1) || (((i + 1) % poly.size()) == edited_point))
331 p2 = edited_point_pos;
332 else
333 p2 = poly[(i + 1) % poly.size()];
334
335 Vector2 point = xform.xform(p);
336 Vector2 next_point = xform.xform(p2);
337
338 Color col = Color(1, 0.3, 0.1, 0.8);
339 vpc->draw_line(point, next_point, col, 2);
340 vpc->draw_texture(handle, point - handle->get_size() * 0.5);
341 }
342 }
343
edit(Node * p_collision_polygon)344 void CollisionPolygon2DEditor::edit(Node *p_collision_polygon) {
345
346 if (!canvas_item_editor) {
347 canvas_item_editor = CanvasItemEditor::get_singleton();
348 }
349
350 if (p_collision_polygon) {
351
352 node = p_collision_polygon->cast_to<CollisionPolygon2D>();
353 if (!canvas_item_editor->get_viewport_control()->is_connected("draw", this, "_canvas_draw"))
354 canvas_item_editor->get_viewport_control()->connect("draw", this, "_canvas_draw");
355 wip.clear();
356 wip_active = false;
357 edited_point = -1;
358 canvas_item_editor->get_viewport_control()->update();
359
360 } else {
361 node = NULL;
362
363 if (canvas_item_editor->get_viewport_control()->is_connected("draw", this, "_canvas_draw"))
364 canvas_item_editor->get_viewport_control()->disconnect("draw", this, "_canvas_draw");
365 }
366 }
367
_bind_methods()368 void CollisionPolygon2DEditor::_bind_methods() {
369
370 ObjectTypeDB::bind_method(_MD("_menu_option"), &CollisionPolygon2DEditor::_menu_option);
371 ObjectTypeDB::bind_method(_MD("_canvas_draw"), &CollisionPolygon2DEditor::_canvas_draw);
372 ObjectTypeDB::bind_method(_MD("_node_removed"), &CollisionPolygon2DEditor::_node_removed);
373 }
374
CollisionPolygon2DEditor(EditorNode * p_editor)375 CollisionPolygon2DEditor::CollisionPolygon2DEditor(EditorNode *p_editor) {
376
377 node = NULL;
378 canvas_item_editor = NULL;
379 editor = p_editor;
380 undo_redo = editor->get_undo_redo();
381
382 add_child(memnew(VSeparator));
383 button_create = memnew(ToolButton);
384 add_child(button_create);
385 button_create->connect("pressed", this, "_menu_option", varray(MODE_CREATE));
386 button_create->set_toggle_mode(true);
387 button_create->set_tooltip(TTR("Create a new polygon from scratch."));
388
389 button_edit = memnew(ToolButton);
390 add_child(button_edit);
391 button_edit->connect("pressed", this, "_menu_option", varray(MODE_EDIT));
392 button_edit->set_toggle_mode(true);
393 button_edit->set_tooltip("Edit existing polygon:\nLMB: Move Point.\nCtrl+LMB: Split Segment.\nRMB: Erase Point.");
394
395 //add_constant_override("separation",0);
396
397 #if 0
398 options = memnew( MenuButton );
399 add_child(options);
400 options->set_area_as_parent_rect();
401 options->set_text("Polygon");
402 //options->get_popup()->add_item("Parse BBCode",PARSE_BBCODE);
403 options->get_popup()->connect("item_pressed", this,"_menu_option");
404 #endif
405
406 mode = MODE_EDIT;
407 wip_active = false;
408 }
409
edit(Object * p_object)410 void CollisionPolygon2DEditorPlugin::edit(Object *p_object) {
411
412 collision_polygon_editor->edit(p_object->cast_to<Node>());
413 }
414
handles(Object * p_object) const415 bool CollisionPolygon2DEditorPlugin::handles(Object *p_object) const {
416
417 return p_object->is_type("CollisionPolygon2D");
418 }
419
make_visible(bool p_visible)420 void CollisionPolygon2DEditorPlugin::make_visible(bool p_visible) {
421
422 if (p_visible) {
423 collision_polygon_editor->show();
424 } else {
425
426 collision_polygon_editor->hide();
427 collision_polygon_editor->edit(NULL);
428 }
429 }
430
CollisionPolygon2DEditorPlugin(EditorNode * p_node)431 CollisionPolygon2DEditorPlugin::CollisionPolygon2DEditorPlugin(EditorNode *p_node) {
432
433 editor = p_node;
434 collision_polygon_editor = memnew(CollisionPolygon2DEditor(p_node));
435 CanvasItemEditor::get_singleton()->add_control_to_menu_panel(collision_polygon_editor);
436
437 collision_polygon_editor->hide();
438 }
439
~CollisionPolygon2DEditorPlugin()440 CollisionPolygon2DEditorPlugin::~CollisionPolygon2DEditorPlugin() {
441 }
442