maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Removed splits in Polygon editor, replace by internal vertices and polygon support.

Browse source
This commit is contained in:
Juan Linietsky 2019-01-08 19:10:24 -03:00
parent d8c40bccbb
commit e46f28e02d
9 changed files with 766 additions and 224 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/math/geometry.cpp
View file

@ -32,6 +32,7 @@
#include "core/print_string.h"
/* this implementation is very inefficient, commenting unless bugs happen. See the other one.
bool Geometry::is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon) {
Vector<int> indices = Geometry::triangulate_polygon(p_polygon);
@ -42,6 +43,7 @@ bool Geometry::is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2>
}
return false;
}
*/
void Geometry::MeshData::optimize_vertices() {

32
core/math/geometry.h
View file

@ -514,7 +514,7 @@ public:
return (cn.cross(an) > 0) == orientation;
}
static bool is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon);
//static bool is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon);
static Vector2 get_closest_point_to_segment_uncapped_2d(const Vector2 &p_point, const Vector2 *p_segment) {
@ -815,6 +815,36 @@ public:
return sum > 0.0f;
}
/* alternate implementation that should be faster */
static bool is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon) {
int c = p_polygon.size();
if (c < 3)
return false;
const Vector2 *p = p_polygon.ptr();
Vector2 further_away(-1e20, -1e20);
Vector2 further_away_opposite(1e20, 1e20);
for (int i = 0; i < c; i++) {
further_away.x = MAX(p[i].x, further_away.x);
further_away.y = MAX(p[i].y, further_away.y);
further_away_opposite.x = MIN(p[i].x, further_away_opposite.x);
further_away_opposite.y = MIN(p[i].y, further_away_opposite.y);
}
further_away += (further_away - further_away_opposite) * Vector2(1.221313, 1.512312); // make point outside that wont intersect with points in segment from p_point
int intersections = 0;
for (int i = 0; i < c; i++) {
const Vector2 &v1 = p[i];
const Vector2 &v2 = p[(i + 1) % c];
if (segment_intersects_segment_2d(v1, v2, p_point, further_away, NULL)) {
intersections++;
}
}
return (intersections & 1);
}
static PoolVector<PoolVector<Face3> > separate_objects(PoolVector<Face3> p_array);
static PoolVector<Face3> wrap_geometry(PoolVector<Face3> p_array, real_t *p_error = NULL); ///< create a "wrap" that encloses the given geometry

67
editor/icons/icon_edit_internal.svg Normal file
View file

@ -0,0 +1,67 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="16"
height="16"
version="1.1"
viewBox="0 0 16 16"
id="svg6"
sodipodi:docname="icon_edit_internal.svg"
inkscape:version="0.92.3 (2405546, 2018-03-11)">
<metadata
id="metadata12">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<defs
id="defs10" />
<sodipodi:namedview
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1"
objecttolerance="10"
gridtolerance="10"
guidetolerance="10"
inkscape:pageopacity="0"
inkscape:pageshadow="2"
inkscape:window-width="1008"
inkscape:window-height="562"
id="namedview8"
showgrid="false"
inkscape:zoom="14.75"
inkscape:cx="9.4237288"
inkscape:cy="8"
inkscape:window-x="649"
inkscape:window-y="95"
inkscape:window-maximized="0"
inkscape:current-layer="svg6" />
<g
transform="translate(-3.322034,-1036.4)"
id="g4">
<path
transform="translate(0,1036.4)"
d="M 7,1 C 6.446,1 6,1.446 6,2 v 2 h 4 V 2 C 10,1.446 9.554,1 9,1 Z M 6,5 v 7 l 2,3 2,-3 V 5 Z m 1,1 h 1 v 5 H 7 Z"
id="path2"
inkscape:connector-curvature="0"
style="fill:#e0e0e0" />
</g>
<circle
style="fill:#e0e0e0;fill-opacity:1"
id="path822"
cx="10.508475"
cy="12.677966"
r="2.3728814" />
</svg>
Side by side

After

Width:  |  Height:  |  Size: 1.9 KiB

70
editor/icons/icon_editor_internal_handle.svg Normal file
View file

@ -0,0 +1,70 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="10"
height="10"
version="1.1"
viewBox="0 0 10 10"
id="svg8"
sodipodi:docname="icon_editor_internal_handle.svg"
inkscape:version="0.92.3 (2405546, 2018-03-11)">
<metadata
id="metadata14">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<defs
id="defs12" />
<sodipodi:namedview
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1"
objecttolerance="10"
gridtolerance="10"
guidetolerance="10"
inkscape:pageopacity="0"
inkscape:pageshadow="2"
inkscape:window-width="1449"
inkscape:window-height="649"
id="namedview10"
showgrid="false"
inkscape:zoom="33.37544"
inkscape:cx="5.3723219"
inkscape:cy="4.9131249"
inkscape:window-x="67"
inkscape:window-y="27"
inkscape:window-maximized="0"
inkscape:current-layer="svg8" />
<circle
cx="5"
cy="5"
r="5"
fill-opacity=".29412"
id="circle2" />
<circle
cx="5"
cy="5"
r="4"
fill="#fff"
id="circle4" />
<circle
cx="5"
cy="5"
r="3"
fill="#ff8484"
id="circle6"
style="fill:#84b1ff;fill-opacity:1" />
</svg>
Side by side

After

Width:  |  Height:  |  Size: 1.8 KiB

67
editor/icons/icon_remove_internal.svg Normal file
View file

@ -0,0 +1,67 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="16"
height="16"
version="1.1"
viewBox="0 0 16 16"
id="svg6"
sodipodi:docname="icon_remove_internal.svg"
inkscape:version="0.92.3 (2405546, 2018-03-11)">
<metadata
id="metadata12">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<defs
id="defs10" />
<sodipodi:namedview
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1"
objecttolerance="10"
gridtolerance="10"
guidetolerance="10"
inkscape:pageopacity="0"
inkscape:pageshadow="2"
inkscape:window-width="1111"
inkscape:window-height="646"
id="namedview8"
showgrid="false"
inkscape:zoom="14.75"
inkscape:cx="9.4237288"
inkscape:cy="12.255032"
inkscape:window-x="649"
inkscape:window-y="95"
inkscape:window-maximized="0"
inkscape:current-layer="svg6" />
<circle
style="fill:#e0e0e0;fill-opacity:1"
id="path822"
cx="10.508475"
cy="12.677966"
r="2.3728814" />
<g
transform="matrix(0.63442593,0,0,0.63442593,0.38221965,-656.59446)"
id="g896">
<path
style="fill:#e0e0e0"
inkscape:connector-curvature="0"
transform="translate(0,1036.4)"
d="M 3.7578,2.3438 2.3437,3.7579 6.5859,8.0001 2.3437,12.2423 3.7578,13.6564 8,9.4142 12.2422,13.6564 13.6563,12.2423 9.4141,8.0001 13.6563,3.7579 12.2422,2.3438 8,6.586 Z"
id="path894" />
</g>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 2 KiB

410
editor/plugins/polygon_2d_editor_plugin.cpp
View file

@ -52,6 +52,14 @@ Vector2 Polygon2DEditor::_get_offset(int p_idx) const {
return node->get_offset();
}
int Polygon2DEditor::_get_polygon_count() const {
if (node->get_internal_vertex_count() > 0) {
return 0; //do not edit if internal vertices exist
} else {
return 1;
}
}
void Polygon2DEditor::_notification(int p_what) {
switch (p_what) {
@ -66,13 +74,15 @@ void Polygon2DEditor::_notification(int p_what) {
button_uv->set_icon(get_icon("Uv", "EditorIcons"));
uv_button[UV_MODE_CREATE]->set_icon(get_icon("Add", "EditorIcons"));
uv_button[UV_MODE_CREATE]->set_icon(get_icon("Edit", "EditorIcons"));
uv_button[UV_MODE_CREATE_INTERNAL]->set_icon(get_icon("EditInternal", "EditorIcons"));
uv_button[UV_MODE_REMOVE_INTERNAL]->set_icon(get_icon("RemoveInternal", "EditorIcons"));
uv_button[UV_MODE_EDIT_POINT]->set_icon(get_icon("ToolSelect", "EditorIcons"));
uv_button[UV_MODE_MOVE]->set_icon(get_icon("ToolMove", "EditorIcons"));
uv_button[UV_MODE_ROTATE]->set_icon(get_icon("ToolRotate", "EditorIcons"));
uv_button[UV_MODE_SCALE]->set_icon(get_icon("ToolScale", "EditorIcons"));
uv_button[UV_MODE_ADD_SPLIT]->set_icon(get_icon("AddSplit", "EditorIcons"));
uv_button[UV_MODE_REMOVE_SPLIT]->set_icon(get_icon("DeleteSplit", "EditorIcons"));
uv_button[UV_MODE_ADD_POLYGON]->set_icon(get_icon("Edit", "EditorIcons"));
uv_button[UV_MODE_REMOVE_POLYGON]->set_icon(get_icon("Close", "EditorIcons"));
uv_button[UV_MODE_PAINT_WEIGHT]->set_icon(get_icon("PaintVertex", "EditorIcons"));
uv_button[UV_MODE_CLEAR_WEIGHT]->set_icon(get_icon("UnpaintVertex", "EditorIcons"));
@ -191,11 +201,13 @@ void Polygon2DEditor::_uv_edit_mode_select(int p_mode) {
if (p_mode == 0) { //uv
uv_button[UV_MODE_CREATE]->hide();
uv_button[UV_MODE_CREATE_INTERNAL]->hide();
uv_button[UV_MODE_REMOVE_INTERNAL]->hide();
for (int i = UV_MODE_MOVE; i <= UV_MODE_SCALE; i++) {
uv_button[i]->show();
}
uv_button[UV_MODE_ADD_SPLIT]->hide();
uv_button[UV_MODE_REMOVE_SPLIT]->hide();
uv_button[UV_MODE_ADD_POLYGON]->hide();
uv_button[UV_MODE_REMOVE_POLYGON]->hide();
uv_button[UV_MODE_PAINT_WEIGHT]->hide();
uv_button[UV_MODE_CLEAR_WEIGHT]->hide();
_uv_mode(UV_MODE_EDIT_POINT);
@ -209,8 +221,8 @@ void Polygon2DEditor::_uv_edit_mode_select(int p_mode) {
for (int i = 0; i <= UV_MODE_SCALE; i++) {
uv_button[i]->show();
}
uv_button[UV_MODE_ADD_SPLIT]->hide();
uv_button[UV_MODE_REMOVE_SPLIT]->hide();
uv_button[UV_MODE_ADD_POLYGON]->hide();
uv_button[UV_MODE_REMOVE_POLYGON]->hide();
uv_button[UV_MODE_PAINT_WEIGHT]->hide();
uv_button[UV_MODE_CLEAR_WEIGHT]->hide();
_uv_mode(UV_MODE_EDIT_POINT);
@ -224,11 +236,11 @@ void Polygon2DEditor::_uv_edit_mode_select(int p_mode) {
for (int i = 0; i <= UV_MODE_SCALE; i++) {
uv_button[i]->hide();
}
uv_button[UV_MODE_ADD_SPLIT]->show();
uv_button[UV_MODE_REMOVE_SPLIT]->show();
uv_button[UV_MODE_ADD_POLYGON]->show();
uv_button[UV_MODE_REMOVE_POLYGON]->show();
uv_button[UV_MODE_PAINT_WEIGHT]->hide();
uv_button[UV_MODE_CLEAR_WEIGHT]->hide();
_uv_mode(UV_MODE_ADD_SPLIT);
_uv_mode(UV_MODE_ADD_POLYGON);
bone_scroll_main_vb->hide();
bone_paint_strength->hide();
@ -236,7 +248,7 @@ void Polygon2DEditor::_uv_edit_mode_select(int p_mode) {
bone_paint_radius_label->hide();
} else if (p_mode == 3) { //bones´
for (int i = 0; i <= UV_MODE_REMOVE_SPLIT; i++) {
for (int i = 0; i <= UV_MODE_REMOVE_POLYGON; i++) {
uv_button[i]->hide();
}
uv_button[UV_MODE_PAINT_WEIGHT]->show();
@ -290,6 +302,7 @@ void Polygon2DEditor::_menu_option(int p_option) {
uv_edit->popup(EditorSettings::get_singleton()->get("interface/dialogs/uv_editor_bounds"));
else
uv_edit->popup_centered_ratio(0.85);
_update_bone_list();
} break;
case UVEDIT_POLYGON_TO_UV: {
@ -348,8 +361,10 @@ void Polygon2DEditor::_cancel_editing() {
uv_create = false;
node->set_uv(uv_create_uv_prev);
node->set_polygon(uv_create_poly_prev);
node->set_internal_vertex_count(uv_create_prev_internal_vertices);
node->set_vertex_colors(uv_create_colors_prev);
node->call("_set_bones", uv_create_bones_prev);
node->set_splits(splits_prev);
node->set_polygons(polygons_prev);
} else if (uv_drag) {
uv_drag = false;
if (uv_edit_mode[0]->is_pressed()) { // Edit UV.
@ -357,9 +372,9 @@ void Polygon2DEditor::_cancel_editing() {
} else if (uv_edit_mode[1]->is_pressed()) { // Edit polygon.
node->set_polygon(points_prev);
}
} else if (split_create) {
split_create = false;
}
polygon_create.clear();
}
void Polygon2DEditor::_commit_action() {
@ -409,7 +424,7 @@ void Polygon2DEditor::_set_snap_step_y(float p_val) {
void Polygon2DEditor::_uv_mode(int p_mode) {
split_create = false;
polygon_create.clear();
uv_drag = false;
uv_create = false;
@ -461,8 +476,10 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
uv_create = true;
uv_create_uv_prev = node->get_uv();
uv_create_poly_prev = node->get_polygon();
uv_create_prev_internal_vertices = node->get_internal_vertex_count();
uv_create_colors_prev = node->get_vertex_colors();
uv_create_bones_prev = node->call("_get_bones");
splits_prev = node->get_splits();
polygons_prev = node->get_polygons();
node->set_polygon(points_prev);
node->set_uv(points_prev);
@ -477,6 +494,10 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
undo_redo->add_undo_method(node, "set_uv", uv_create_uv_prev);
undo_redo->add_do_method(node, "set_polygon", node->get_polygon());
undo_redo->add_undo_method(node, "set_polygon", uv_create_poly_prev);
undo_redo->add_do_method(node, "set_internal_vertex_count", 0);
undo_redo->add_undo_method(node, "set_internal_vertex_count", uv_create_prev_internal_vertices);
undo_redo->add_do_method(node, "set_vertex_colors", Vector<Color>());
undo_redo->add_undo_method(node, "set_vertex_colors", uv_create_colors_prev);
undo_redo->add_do_method(node, "clear_bones");
undo_redo->add_undo_method(node, "_set_bones", uv_create_bones_prev);
undo_redo->add_do_method(uv_edit_draw, "update");
@ -499,6 +520,97 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
CanvasItemEditor::get_singleton()->update_viewport();
}
if (uv_move_current == UV_MODE_CREATE_INTERNAL) {
uv_create_uv_prev = node->get_uv();
uv_create_poly_prev = node->get_polygon();
uv_create_colors_prev = node->get_vertex_colors();
uv_create_bones_prev = node->call("_get_bones");
int internal_vertices = node->get_internal_vertex_count();
Vector2 pos = mtx.affine_inverse().xform(snap_point(Vector2(mb->get_position().x, mb->get_position().y)));
uv_create_poly_prev.push_back(pos);
uv_create_uv_prev.push_back(pos);
if (uv_create_colors_prev.size()) {
uv_create_colors_prev.push_back(Color(1, 1, 1));
}
undo_redo->create_action(TTR("Create Internal Vertex"));
undo_redo->add_do_method(node, "set_uv", uv_create_uv_prev);
undo_redo->add_undo_method(node, "set_uv", node->get_uv());
undo_redo->add_do_method(node, "set_polygon", uv_create_poly_prev);
undo_redo->add_undo_method(node, "set_polygon", node->get_polygon());
undo_redo->add_do_method(node, "set_vertex_colors", uv_create_colors_prev);
undo_redo->add_undo_method(node, "set_vertex_colors", node->get_vertex_colors());
for (int i = 0; i < node->get_bone_count(); i++) {
PoolVector<float> bonew = node->get_bone_weights(i);
bonew.push_back(0);
undo_redo->add_do_method(node, "set_bone_weights", i, bonew);
undo_redo->add_undo_method(node, "set_bone_weights", i, node->get_bone_weights(i));
}
undo_redo->add_do_method(node, "set_internal_vertex_count", internal_vertices + 1);
undo_redo->add_undo_method(node, "set_internal_vertex_count", internal_vertices);
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
}
if (uv_move_current == UV_MODE_REMOVE_INTERNAL) {
uv_create_uv_prev = node->get_uv();
uv_create_poly_prev = node->get_polygon();
uv_create_colors_prev = node->get_vertex_colors();
uv_create_bones_prev = node->call("_get_bones");
int internal_vertices = node->get_internal_vertex_count();
if (internal_vertices <= 0)
return;
int closest = -1;
float closest_dist = 1e20;
for (int i = points_prev.size() - internal_vertices; i < points_prev.size(); i++) {
Vector2 tuv = mtx.xform(uv_create_poly_prev[i]);
float dist = tuv.distance_to(Vector2(mb->get_position().x, mb->get_position().y));
if (dist < 8 && dist < closest_dist) {
closest = i;
closest_dist = dist;
}
}
if (closest == -1)
return;
uv_create_poly_prev.remove(closest);
uv_create_uv_prev.remove(closest);
if (uv_create_colors_prev.size()) {
uv_create_colors_prev.remove(closest);
}
undo_redo->create_action(TTR("Remove Internal Vertex"));
undo_redo->add_do_method(node, "set_uv", uv_create_uv_prev);
undo_redo->add_undo_method(node, "set_uv", node->get_uv());
undo_redo->add_do_method(node, "set_polygon", uv_create_poly_prev);
undo_redo->add_undo_method(node, "set_polygon", node->get_polygon());
undo_redo->add_do_method(node, "set_vertex_colors", uv_create_colors_prev);
undo_redo->add_undo_method(node, "set_vertex_colors", node->get_vertex_colors());
for (int i = 0; i < node->get_bone_count(); i++) {
PoolVector<float> bonew = node->get_bone_weights(i);
bonew.remove(closest);
undo_redo->add_do_method(node, "set_bone_weights", i, bonew);
undo_redo->add_undo_method(node, "set_bone_weights", i, node->get_bone_weights(i));
}
undo_redo->add_do_method(node, "set_internal_vertex_count", internal_vertices - 1);
undo_redo->add_undo_method(node, "set_internal_vertex_count", internal_vertices);
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
}
if (uv_move_current == UV_MODE_EDIT_POINT) {
if (mb->get_shift() && mb->get_command())
@ -526,129 +638,80 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
}
}
if (uv_move_current == UV_MODE_ADD_SPLIT) {
if (uv_move_current == UV_MODE_ADD_POLYGON) {
int closest = -1;
float closest_dist = 1e20;
int split_to_index = -1;
split_to_index = -1;
for (int i = 0; i < points_prev.size(); i++) {
Vector2 tuv = mtx.xform(points_prev[i]);
if (tuv.distance_to(Vector2(mb->get_position().x, mb->get_position().y)) < 8) {
split_to_index = i;
float dist = tuv.distance_to(Vector2(mb->get_position().x, mb->get_position().y));
if (dist < 8 && dist < closest_dist) {
closest = i;
closest_dist = dist;
}
}
if (split_to_index == -1) {
split_create = false;
return;
}
if (split_create) {
split_create = false;
if (split_to_index < point_drag_index) {
SWAP(split_to_index, point_drag_index);
}
bool valid = true;
String split_error;
if (split_to_index == point_drag_index) {
split_error = TTR("Split point with itself.");
valid = false;
}
if (split_to_index + 1 == point_drag_index) {
//not a split,goes along the edge
split_error = TTR("Split can't form an existing edge.");
valid = false;
}
if (split_to_index == points_prev.size() - 1 && point_drag_index == 0) {
//not a split,goes along the edge
split_error = TTR("Split can't form an existing edge.");
valid = false;
}
for (int i = 0; i < splits_prev.size(); i += 2) {
if (splits_prev[i] == point_drag_index && splits_prev[i + 1] == split_to_index) {
//already exists
split_error = TTR("Split already exists.");
valid = false;
break;
}
int a_state; //-1, outside split, 0 split point, +1, inside split
if (point_drag_index == splits_prev[i] || point_drag_index == splits_prev[i + 1]) {
a_state = 0;
} else if (point_drag_index < splits_prev[i] || point_drag_index > splits_prev[i + 1]) {
a_state = -1;
if (closest != -1) {
if (polygon_create.size() && closest == polygon_create[0]) {
//close
if (polygon_create.size() < 3) {
error->set_text(TTR("Invalid Polygon (need 3 different vertices)"));
error->popup_centered_minsize();
} else {
a_state = 1;
Array polygons = node->get_polygons();
polygons = polygons.duplicate(); //copy because its a reference
//todo, could check whether it already exists?
polygons.push_back(polygon_create);
undo_redo->create_action(TTR("Add Polygon"));
undo_redo->add_do_method(node, "set_polygons", polygons);
undo_redo->add_undo_method(node, "set_polygons", polygons_prev);
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
}
int b_state; //-1, outside split, 0 split point, +1, inside split
if (split_to_index == splits_prev[i] || split_to_index == splits_prev[i + 1]) {
b_state = 0;
} else if (split_to_index < splits_prev[i] || split_to_index > splits_prev[i + 1]) {
b_state = -1;
} else {
b_state = 1;
}
if (b_state * a_state < 0) {
//crossing
split_error = "Split crosses another split.";
valid = false;
break;
}
polygon_create.clear();
} else if (polygon_create.find(closest) == -1) {
//add temporarily if not exists
polygon_create.push_back(closest);
}
if (valid) {
splits_prev.push_back(point_drag_index);
splits_prev.push_back(split_to_index);
undo_redo->create_action(TTR("Add Split"));
undo_redo->add_do_method(node, "set_splits", splits_prev);
undo_redo->add_undo_method(node, "set_splits", node->get_splits());
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
} else {
error->set_text(TTR("Invalid Split: ") + split_error);
error->popup_centered_minsize();
}
} else {
point_drag_index = split_to_index;
split_create = true;
splits_prev = node->get_splits();
uv_create_to = mtx.affine_inverse().xform(Vector2(mb->get_position().x, mb->get_position().y));
}
}
if (uv_move_current == UV_MODE_REMOVE_SPLIT) {
if (uv_move_current == UV_MODE_REMOVE_POLYGON) {
Array polygons = node->get_polygons();
polygons = polygons.duplicate(); //copy because its a reference
splits_prev = node->get_splits();
for (int i = 0; i < splits_prev.size(); i += 2) {
if (splits_prev[i] < 0 || splits_prev[i] >= points_prev.size())
continue;
if (splits_prev[i + 1] < 0 || splits_prev[i] >= points_prev.size())
continue;
Vector2 e[2] = { mtx.xform(points_prev[splits_prev[i]]), mtx.xform(points_prev[splits_prev[i + 1]]) };
Vector2 mp = Vector2(mb->get_position().x, mb->get_position().y);
Vector2 cp = Geometry::get_closest_point_to_segment_2d(mp, e);
if (cp.distance_to(mp) < 8) {
splits_prev.remove(i);
splits_prev.remove(i);
int erase_index = -1;
for (int i = polygons.size() - 1; i >= 0; i--) {
PoolVector<int> points = polygons[i];
Vector<Vector2> polys;
polys.resize(points.size());
for (int j = 0; j < polys.size(); j++) {
int idx = points[j];
if (idx < 0 || idx >= points_prev.size())
continue;
polys.write[j] = mtx.xform(points_prev[idx]);
}
undo_redo->create_action(TTR("Remove Split"));
undo_redo->add_do_method(node, "set_splits", splits_prev);
undo_redo->add_undo_method(node, "set_splits", node->get_splits());
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
if (Geometry::is_point_in_polygon(Vector2(mb->get_position().x, mb->get_position().y), polys)) {
erase_index = i;
break;
}
}
if (erase_index != -1) {
polygons.remove(erase_index);
undo_redo->create_action(TTR("Remove Polygon"));
undo_redo->add_do_method(node, "set_polygons", polygons);
undo_redo->add_undo_method(node, "set_polygons", polygons_prev);
undo_redo->add_do_method(uv_edit_draw, "update");
undo_redo->add_undo_method(uv_edit_draw, "update");
undo_redo->commit_action();
}
}
if (uv_move_current == UV_MODE_PAINT_WEIGHT || uv_move_current == UV_MODE_CLEAR_WEIGHT) {
@ -849,7 +912,7 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
uv_edit_draw->update();
CanvasItemEditor::get_singleton()->update_viewport();
} else if (split_create) {
} else if (polygon_create.size()) {
uv_create_to = mtx.affine_inverse().xform(Vector2(mm->get_position().x, mm->get_position().y));
uv_edit_draw->update();
} else if (uv_mode == UV_MODE_PAINT_WEIGHT || uv_mode == UV_MODE_CLEAR_WEIGHT) {
@ -930,6 +993,8 @@ void Polygon2DEditor::_uv_draw() {
}
}
Array polygons = node->get_polygons();
PoolVector<Vector2> uvs;
if (uv_edit_mode[0]->is_pressed()) { //edit uv
uvs = node->get_uv();
@ -956,17 +1021,54 @@ void Polygon2DEditor::_uv_draw() {
}
Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
Ref<Texture> internal_handle = get_icon("EditorInternalHandle", "EditorIcons");
Color poly_line_color = Color(0.9, 0.5, 0.5);
Color polygon_line_color = Color(0.5, 0.5, 0.9);
Vector<Color> polygon_fill_color;
{
Color pf = polygon_line_color;
pf.a *= 0.5;
polygon_fill_color.push_back(pf);
}
Color prev_color = Color(0.5, 0.5, 0.5);
Rect2 rect(Point2(), mtx.basis_xform(base_tex->get_size()));
rect.expand_to(mtx.basis_xform(uv_edit_draw->get_size()));
int uv_draw_max = uvs.size();
for (int i = 0; i < polygons.size(); i++) {
PoolVector<int> points = polygons[i];
Vector<Vector2> polypoints;
for (int i = 0; i < points.size(); i++) {
int next = (i + 1) % points.size();
int idx = points[i];
int idx_next = points[next];
if (idx < 0 || idx >= uvs.size())
continue;
polypoints.push_back(mtx.xform(uvs[idx]));
if (idx_next < 0 || idx_next >= uvs.size())
continue;
uv_edit_draw->draw_line(mtx.xform(uvs[idx]), mtx.xform(uvs[idx_next]), polygon_line_color, 2 * EDSCALE);
}
if (points.size() >= 3) {
uv_edit_draw->draw_polygon(polypoints, polygon_fill_color);
}
}
uv_draw_max -= node->get_internal_vertex_count();
if (uv_draw_max < 0) {
uv_draw_max = 0;
}
for (int i = 0; i < uvs.size(); i++) {
int next = (i + 1) % uvs.size();
int next = uv_draw_max > 0 ? (i + 1) % uv_draw_max : 0;
if (uv_drag && uv_move_current == UV_MODE_EDIT_POINT && EDITOR_DEF("editors/poly_editor/show_previous_outline", true)) {
if (i < uv_draw_max && uv_drag && uv_move_current == UV_MODE_EDIT_POINT && EDITOR_DEF("editors/poly_editor/show_previous_outline", true)) {
uv_edit_draw->draw_line(mtx.xform(points_prev[i]), mtx.xform(points_prev[next]), prev_color, 2 * EDSCALE);
}
@ -974,24 +1076,33 @@ void Polygon2DEditor::_uv_draw() {
if (uv_create && i == uvs.size() - 1) {
next_point = uv_create_to;
}
uv_edit_draw->draw_line(mtx.xform(uvs[i]), mtx.xform(next_point), poly_line_color, 2 * EDSCALE);
if (i < uv_draw_max && polygons.size() == 0 && polygon_create.size() == 0) { //if using or creating polygons, do not show outline (will show polygons instead)
uv_edit_draw->draw_line(mtx.xform(uvs[i]), mtx.xform(next_point), poly_line_color, 2 * EDSCALE);
}
if (weight_r.ptr()) {
Vector2 draw_pos = mtx.xform(uvs[i]);
float weight = weight_r[i];
uv_edit_draw->draw_rect(Rect2(draw_pos - Vector2(2, 2) * EDSCALE, Vector2(5, 5) * EDSCALE), Color(weight, weight, weight, 1.0));
} else {
uv_edit_draw->draw_texture(handle, mtx.xform(uvs[i]) - handle->get_size() * 0.5);
if (i < uv_draw_max) {
uv_edit_draw->draw_texture(handle, mtx.xform(uvs[i]) - handle->get_size() * 0.5);
} else {
uv_edit_draw->draw_texture(internal_handle, mtx.xform(uvs[i]) - internal_handle->get_size() * 0.5);
}
}
rect.expand_to(mtx.basis_xform(uvs[i]));
}
if (split_create) {
Vector2 from = uvs[point_drag_index];
Vector2 to = uv_create_to;
uv_edit_draw->draw_line(mtx.xform(from), mtx.xform(to), poly_line_color, 2);
if (polygon_create.size()) {
for (int i = 0; i < polygon_create.size(); i++) {
Vector2 from = uvs[polygon_create[i]];
Vector2 to = (i + 1) < polygon_create.size() ? uvs[polygon_create[i + 1]] : uv_create_to;
uv_edit_draw->draw_line(mtx.xform(from), mtx.xform(to), poly_line_color, 2);
}
}
#if 0
PoolVector<int> splits = node->get_splits();
for (int i = 0; i < splits.size(); i += 2) {
@ -1001,7 +1112,7 @@ void Polygon2DEditor::_uv_draw() {
continue;
uv_edit_draw->draw_line(mtx.xform(uvs[idx_from]), mtx.xform(uvs[idx_to]), poly_line_color, 2);
}
#endif
if (uv_mode == UV_MODE_PAINT_WEIGHT || uv_mode == UV_MODE_CLEAR_WEIGHT) {
NodePath bone_path;
@ -1155,8 +1266,8 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_edit_mode[0]->set_text(TTR("UV"));
uv_edit_mode[0]->set_pressed(true);
uv_edit_mode[1]->set_text(TTR("Poly"));
uv_edit_mode[2]->set_text(TTR("Splits"));
uv_edit_mode[1]->set_text(TTR("Points"));
uv_edit_mode[2]->set_text(TTR("Polygons"));
uv_edit_mode[3]->set_text(TTR("Bones"));
uv_edit_mode[0]->set_button_group(uv_edit_group);
@ -1181,22 +1292,26 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_button[i]->set_focus_mode(FOCUS_NONE);
}
uv_button[0]->set_tooltip(TTR("Create Polygon"));
uv_button[1]->set_tooltip(TTR("Move Points") + "\n" + TTR("Ctrl: Rotate") + "\n" + TTR("Shift: Move All") + "\n" + TTR("Shift+Ctrl: Scale"));
uv_button[2]->set_tooltip(TTR("Move Polygon"));
uv_button[3]->set_tooltip(TTR("Rotate Polygon"));
uv_button[4]->set_tooltip(TTR("Scale Polygon"));
uv_button[5]->set_tooltip(TTR("Connect two points to make a split."));
uv_button[6]->set_tooltip(TTR("Select a split to erase it."));
uv_button[7]->set_tooltip(TTR("Paint weights with specified intensity."));
uv_button[8]->set_tooltip(TTR("Unpaint weights with specified intensity."));
uv_button[UV_MODE_CREATE]->set_tooltip(TTR("Create Polygon"));
uv_button[UV_MODE_CREATE_INTERNAL]->set_tooltip(TTR("Create Internal Vertex"));
uv_button[UV_MODE_REMOVE_INTERNAL]->set_tooltip(TTR("Erase Internal Vertex"));
uv_button[UV_MODE_EDIT_POINT]->set_tooltip(TTR("Move Points") + "\n" + TTR("Ctrl: Rotate") + "\n" + TTR("Shift: Move All") + "\n" + TTR("Shift+Ctrl: Scale"));
uv_button[UV_MODE_MOVE]->set_tooltip(TTR("Move Polygon"));
uv_button[UV_MODE_ROTATE]->set_tooltip(TTR("Rotate Polygon"));
uv_button[UV_MODE_SCALE]->set_tooltip(TTR("Scale Polygon"));
uv_button[UV_MODE_ADD_POLYGON]->set_tooltip(TTR("Create a custom polygon. Enables custom polygon rendering."));
uv_button[UV_MODE_REMOVE_POLYGON]->set_tooltip(TTR("Remove a custom polygon. If none remain, custom polygon rendering is disabled."));
uv_button[UV_MODE_PAINT_WEIGHT]->set_tooltip(TTR("Paint weights with specified intensity."));
uv_button[UV_MODE_CLEAR_WEIGHT]->set_tooltip(TTR("Unpaint weights with specified intensity."));
uv_button[0]->hide();
uv_button[5]->hide();
uv_button[6]->hide();
uv_button[7]->hide();
uv_button[8]->hide();
uv_button[1]->set_pressed(true);
uv_button[UV_MODE_CREATE]->hide();
uv_button[UV_MODE_CREATE_INTERNAL]->hide();
uv_button[UV_MODE_REMOVE_INTERNAL]->hide();
uv_button[UV_MODE_ADD_POLYGON]->hide();
uv_button[UV_MODE_REMOVE_POLYGON]->hide();
uv_button[UV_MODE_PAINT_WEIGHT]->hide();
uv_button[UV_MODE_CLEAR_WEIGHT]->hide();
uv_button[UV_MODE_EDIT_POINT]->set_pressed(true);
bone_paint_strength = memnew(HSlider);
uv_mode_hb->add_child(bone_paint_strength);
@ -1354,7 +1469,6 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_drag = false;
uv_create = false;
updating_uv_scroll = false;
split_create = false;
bone_painting = false;
error = memnew(AcceptDialog);

14
editor/plugins/polygon_2d_editor_plugin.h
View file

@ -50,12 +50,14 @@ class Polygon2DEditor : public AbstractPolygon2DEditor {
enum UVMode {
UV_MODE_CREATE,
UV_MODE_CREATE_INTERNAL,
UV_MODE_REMOVE_INTERNAL,
UV_MODE_EDIT_POINT,
UV_MODE_MOVE,
UV_MODE_ROTATE,
UV_MODE_SCALE,
UV_MODE_ADD_SPLIT,
UV_MODE_REMOVE_SPLIT,
UV_MODE_ADD_POLYGON,
UV_MODE_REMOVE_POLYGON,
UV_MODE_PAINT_WEIGHT,
UV_MODE_CLEAR_WEIGHT,
UV_MODE_MAX
@ -100,14 +102,16 @@ class Polygon2DEditor : public AbstractPolygon2DEditor {
PoolVector<Vector2> points_prev;
PoolVector<Vector2> uv_create_uv_prev;
PoolVector<Vector2> uv_create_poly_prev;
PoolVector<Color> uv_create_colors_prev;
int uv_create_prev_internal_vertices;
Array uv_create_bones_prev;
PoolVector<int> splits_prev;
Array polygons_prev;
Vector2 uv_create_to;
int point_drag_index;
bool uv_drag;
bool uv_create;
bool split_create;
Vector<int> polygon_create;
UVMode uv_move_current;
Vector2 uv_drag_from;
bool updating_uv_scroll;
@ -141,6 +145,8 @@ class Polygon2DEditor : public AbstractPolygon2DEditor {
void _uv_edit_popup_hide();
void _bone_paint_selected(int p_index);
int _get_polygon_count() const;
protected:
virtual Node2D *_get_node() const;
virtual void _set_node(Node *p_polygon);

318
scene/2d/polygon_2d.cpp
View file

@ -81,7 +81,11 @@ bool Polygon2D::_edit_use_rect() const {
bool Polygon2D::_edit_is_selected_on_click(const Point2 &p_point, double p_tolerance) const {
return Geometry::is_point_in_polygon(p_point - get_offset(), Variant(polygon));
Vector<Vector2> polygon2d = Variant(polygon);
if (internal_vertices > 0) {
polygon2d.resize(polygon2d.size() - internal_vertices);
}
return Geometry::is_point_in_polygon(p_point - get_offset(), polygon2d);
}
void Polygon2D::_notification(int p_what) {
@ -108,9 +112,17 @@ void Polygon2D::_notification(int p_what) {
Vector<int> bones;
Vector<float> weights;
points.resize(polygon.size());
int len = polygon.size();
if ((invert || polygons.size() == 0) && internal_vertices > 0) {
//if no polygons are around, internal vertices must not be drawn, else let them be
len -= internal_vertices;
}
if (len <= 0) {
return;
}
points.resize(len);
int len = points.size();
{
PoolVector<Vector2>::Read polyr = polygon.read();
@ -177,7 +189,8 @@ void Polygon2D::_notification(int p_what) {
Transform2D texmat(tex_rot, tex_ofs);
texmat.scale(tex_scale);
Size2 tex_size = texture->get_size();
uvs.resize(points.size());
uvs.resize(len);
if (points.size() == uv.size()) {
@ -196,7 +209,7 @@ void Polygon2D::_notification(int p_what) {
if (skeleton_node && !invert && bone_weights.size()) {
//a skeleton is set! fill indices and weights
int vc = points.size();
int vc = len;
bones.resize(vc * 4);
weights.resize(vc * 4);
@ -211,12 +224,15 @@ void Polygon2D::_notification(int p_what) {
for (int i = 0; i < bone_weights.size(); i++) {
if (bone_weights[i].weights.size() != points.size()) {
continue; //different number of vertices, sorry not using.
print_line("wrong weight size");
}
if (!skeleton_node->has_node(bone_weights[i].path)) {
print_line("no node");
continue; //node does not exist
}
Bone2D *bone = Object::cast_to<Bone2D>(skeleton_node->get_node(bone_weights[i].path));
if (!bone) {
print_line("no bone");
continue;
}
@ -258,93 +274,245 @@ void Polygon2D::_notification(int p_what) {
}
Vector<Color> colors;
int color_len = vertex_colors.size();
colors.resize(len);
{
if (vertex_colors.size() == points.size()) {
colors.resize(len);
PoolVector<Color>::Read color_r = vertex_colors.read();
for (int i = 0; i < color_len && i < len; i++) {
for (int i = 0; i < len; i++) {
colors.write[i] = color_r[i];
}
for (int i = color_len; i < len; i++) {
colors.write[i] = color;
}
} else {
colors.push_back(color);
}
// Vector<int> indices = Geometry::triangulate_polygon(points);
// VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, texture.is_valid() ? texture->get_rid() : RID());
if (invert || splits.size() == 0) {
if (invert || polygons.size() == 0) {
Vector<int> indices = Geometry::triangulate_polygon(points);
VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID());
} else {
//draw individual polygons
Vector<int> total_indices;
for (int i = 0; i < polygons.size(); i++) {
PoolVector<int> src_indices = polygons[i];
int ic = src_indices.size();
if (ic < 3)
continue;
PoolVector<int>::Read r = src_indices.read();
Vector<Vector2> tmp_points;
tmp_points.resize(ic);
for (int j = 0; j < ic; j++) {
int idx = r[j];
ERR_CONTINUE(idx < 0 || idx >= points.size());
tmp_points.write[j] = points[r[j]];
}
Vector<int> indices = Geometry::triangulate_polygon(tmp_points);
int ic2 = indices.size();
const int *r2 = indices.ptr();
int bic = total_indices.size();
total_indices.resize(bic + ic2);
int *w2 = total_indices.ptrw();
for (int j = 0; j < ic2; j++) {
w2[j + bic] = r[r2[j]];
}
}
if (total_indices.size()) {
VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), total_indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID());
}
#if 0
//use splits
Vector<int> loop;
int sc = splits.size();
PoolVector<int>::Read r = splits.read();
int last = points.size();
print_line("has splits, amount " + itos(splits.size()));
Vector<Vector<int> > loops;
for (int i = 0; i < last; i++) {
// find a point that can be used to begin, must not be in a split, and have to the left and right the same one
// like this one -> x---o
// \ / \ .
// o---o
int base_point = -1;
{
int current_point = -1;
int base_point_prev_split = -1;
int split;
int min_end = -1;
do {
for (int i = 0; i < points.size(); i++) {
loop.push_back(i);
split = -1;
int end = -1;
//find if this point is in a split
int split_index = -1;
bool has_prev_split = false;
int min_dist_to_end = 0x7FFFFFFF;
for (int j = 0; j < sc; j += 2) {
if (r[j + 1] >= last)
continue; //no longer valid
if (min_end != -1 && r[j + 1] >= min_end)
continue;
if (r[j] == i) {
if (split == -1 || r[j + 1] > end) {
split = r[j];
end = r[j + 1];
}
int split_pos = -1;
int split_end = -1;
if (r[j + 0] == i) { //found split in first point
split_pos = r[j + 0];
split_end = r[j + 1];
} else if (r[j + 1] == i) { //found split in second point
split_pos = r[j + 1];
split_end = r[j + 0];
}
if (split_pos == split_end) {
continue; //either nothing found or begin == end, this not a split in either case
}
if (j == base_point_prev_split) {
has_prev_split = true;
}
//compute distance from split pos to split end in current traversal direction
int dist_to_end = split_end > split_pos ? split_end - split_pos : (last - split_pos + split_end);
if (dist_to_end < min_dist_to_end) {
//always keep the valid split with the least distance to the loop
min_dist_to_end = dist_to_end;
split_index = j;
}
}
if (split != -1) {
for (int j = end; j < last; j++) {
loop.push_back(j);
}
loops.push_back(loop);
last = end + 1;
loop.clear();
min_end = end; //avoid this split from repeating
if (split_index == -1) {
current_point = i; //no split here, we are testing this point
} else if (has_prev_split) {
base_point = current_point; // there is a split and it contains the previous visited split, success
break;
} else {
//invalidate current point and keep split
current_point = -1;
base_point_prev_split = split_index;
}
} while (split != -1);
}
}
if (loop.size()) {
print_line("found base point: " + itos(base_point));
if (base_point != -1) {
int point = base_point;
int last = base_point;
//go through all the points, find splits
do {
int split;
int last_dist_to_end = -1; //maximum valid distance to end
do {
loop.push_back(point); //push current point
split = -1;
int end = -1;
int max_dist_to_end = 0;
//find if this point is in a split
for (int j = 0; j < sc; j += 2) {
int split_pos = -1;
int split_end = -1;
if (r[j + 0] == point) { //match first split index
split_pos = r[j + 0];
split_end = r[j + 1];
} else if (r[j + 1] == point) { //match second split index
split_pos = r[j + 1];
split_end = r[j + 0];
}
if (split_pos == split_end) {
continue; //either nothing found or begin == end, this not a split in either case
}
//compute distance from split pos to split end
int dist_to_end = split_end > split_pos ? split_end - split_pos : (points.size() - split_pos + split_end);
if (last_dist_to_end != -1 && dist_to_end >= last_dist_to_end) {
//distance must be shorter than in last iteration, means we've tested this before so ignore
continue;
} else if (dist_to_end > max_dist_to_end) {
//always keep the valid point with the most distance (as long as it's valid)
max_dist_to_end = dist_to_end;
split = split_pos;
end = split_end;
}
}
if (split != -1) {
//found a split!
int from = end;
//add points until last is reached
while (true) {
//find if point is in a split
loop.push_back(from);
if (from == last) {
break;
}
from++;
if (from >= points.size()) { //wrap if reached end
from = 0;
}
if (from == loop[0]) {
break; //end because we reached split source
}
}
loops.push_back(loop); //done with this loop
loop.clear();
last_dist_to_end = max_dist_to_end;
last = end; //algorithm can safely finish in this split point
}
} while (split != -1);
} while (point != last);
}
if (loop.size() >=2 ) { //points remained
//points remain
loop.push_back(last); //no splits found, use last
loops.push_back(loop);
}
Vector<int> indices;
print_line("total loops: " + itos(loops.size()));
for (int i = 0; i < loops.size(); i++) {
Vector<int> loop = loops[i];
Vector<Vector2> vertices;
vertices.resize(loop.size());
for (int j = 0; j < vertices.size(); j++) {
vertices.write[j] = points[loop[j]];
}
Vector<int> sub_indices = Geometry::triangulate_polygon(vertices);
int from = indices.size();
indices.resize(from + sub_indices.size());
for (int j = 0; j < sub_indices.size(); j++) {
indices.write[from + j] = loop[sub_indices[j]];
if (loops.size()) { //loops found
Vector<int> indices;
for (int i = 0; i < loops.size(); i++) {
Vector<int> loop = loops[i];
Vector<Vector2> vertices;
vertices.resize(loop.size());
for (int j = 0; j < vertices.size(); j++) {
vertices.write[j] = points[loop[j]];
}
Vector<int> sub_indices = Geometry::triangulate_polygon(vertices);
int from = indices.size();
indices.resize(from + sub_indices.size());
for (int j = 0; j < sub_indices.size(); j++) {
indices.write[from + j] = loop[sub_indices[j]];
}
}
VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID());
}
VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID());
#endif
}
} break;
@ -362,6 +530,15 @@ PoolVector<Vector2> Polygon2D::get_polygon() const {
return polygon;
}
void Polygon2D::set_internal_vertex_count(int p_count) {
internal_vertices = p_count;
}
int Polygon2D::get_internal_vertex_count() const {
return internal_vertices;
}
void Polygon2D::set_uv(const PoolVector<Vector2> &p_uv) {
uv = p_uv;
@ -373,16 +550,15 @@ PoolVector<Vector2> Polygon2D::get_uv() const {
return uv;
}
void Polygon2D::set_splits(const PoolVector<int> &p_splits) {
void Polygon2D::set_polygons(const Array &p_polygons) {
ERR_FAIL_COND(p_splits.size() & 1); //splits should be multiple of 2
splits = p_splits;
polygons = p_polygons;
update();
}
PoolVector<int> Polygon2D::get_splits() const {
Array Polygon2D::get_polygons() const {
return splits;
return polygons;
}
void Polygon2D::set_color(const Color &p_color) {
@ -585,8 +761,8 @@ void Polygon2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_color", "color"), &Polygon2D::set_color);
ClassDB::bind_method(D_METHOD("get_color"), &Polygon2D::get_color);
ClassDB::bind_method(D_METHOD("set_splits", "splits"), &Polygon2D::set_splits);
ClassDB::bind_method(D_METHOD("get_splits"), &Polygon2D::get_splits);
ClassDB::bind_method(D_METHOD("set_polygons", "polygons"), &Polygon2D::set_polygons);
ClassDB::bind_method(D_METHOD("get_polygons"), &Polygon2D::get_polygons);
ClassDB::bind_method(D_METHOD("set_vertex_colors", "vertex_colors"), &Polygon2D::set_vertex_colors);
ClassDB::bind_method(D_METHOD("get_vertex_colors"), &Polygon2D::get_vertex_colors);
@ -630,14 +806,13 @@ void Polygon2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_skeleton", "skeleton"), &Polygon2D::set_skeleton);
ClassDB::bind_method(D_METHOD("get_skeleton"), &Polygon2D::get_skeleton);
ClassDB::bind_method(D_METHOD("set_internal_vertex_count", "internal_vertex_count"), &Polygon2D::set_internal_vertex_count);
ClassDB::bind_method(D_METHOD("get_internal_vertex_count"), &Polygon2D::get_internal_vertex_count);
ClassDB::bind_method(D_METHOD("_set_bones", "bones"), &Polygon2D::_set_bones);
ClassDB::bind_method(D_METHOD("_get_bones"), &Polygon2D::_get_bones);
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "polygon"), "set_polygon", "get_polygon");
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "uv"), "set_uv", "get_uv");
ADD_PROPERTY(PropertyInfo(Variant::POOL_INT_ARRAY, "splits"), "set_splits", "get_splits");
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "color"), "set_color", "get_color");
ADD_PROPERTY(PropertyInfo(Variant::POOL_COLOR_ARRAY, "vertex_colors"), "set_vertex_colors", "get_vertex_colors");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "offset"), "set_offset", "get_offset");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "antialiased"), "set_antialiased", "get_antialiased");
ADD_GROUP("Texture", "");
@ -654,7 +829,13 @@ void Polygon2D::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "invert_enable"), "set_invert", "get_invert");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "invert_border", PROPERTY_HINT_RANGE, "0.1,16384,0.1"), "set_invert_border", "get_invert_border");
ADD_GROUP("Data", "");
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "polygon"), "set_polygon", "get_polygon");
ADD_PROPERTY(PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "uv"), "set_uv", "get_uv");
ADD_PROPERTY(PropertyInfo(Variant::POOL_COLOR_ARRAY, "vertex_colors"), "set_vertex_colors", "get_vertex_colors");
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "polygons"), "set_polygons", "get_polygons");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bones", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_bones", "_get_bones");
ADD_PROPERTY(PropertyInfo(Variant::INT, "internal_vertex_count", PROPERTY_HINT_RANGE, "0,1000"), "set_internal_vertex_count", "get_internal_vertex_count");
}
Polygon2D::Polygon2D() {
@ -667,4 +848,5 @@ Polygon2D::Polygon2D() {
tex_scale = Vector2(1, 1);
color = Color(1, 1, 1);
rect_cache_dirty = true;
internal_vertices = 0;
}

10
scene/2d/polygon_2d.h
View file

@ -40,7 +40,8 @@ class Polygon2D : public Node2D {
PoolVector<Vector2> polygon;
PoolVector<Vector2> uv;
PoolVector<Color> vertex_colors;
PoolVector<int> splits;
Array polygons;
int internal_vertices;
struct Bone {
NodePath path;
@ -87,11 +88,14 @@ public:
void set_polygon(const PoolVector<Vector2> &p_polygon);
PoolVector<Vector2> get_polygon() const;
void set_internal_vertex_count(int p_count);
int get_internal_vertex_count() const;
void set_uv(const PoolVector<Vector2> &p_uv);
PoolVector<Vector2> get_uv() const;
void set_splits(const PoolVector<int> &p_uv);
PoolVector<int> get_splits() const;
void set_polygons(const Array &p_polygons);
Array get_polygons() const;
void set_color(const Color &p_color);
Color get_color() const;