2
0

polygon_2d.cpp 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742
  1. /**************************************************************************/
  2. /* polygon_2d.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  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 "polygon_2d.h"
  31. #include "core/math/geometry_2d.h"
  32. #ifndef NAVIGATION_2D_DISABLED
  33. #include "scene/resources/2d/navigation_mesh_source_geometry_data_2d.h"
  34. #include "scene/resources/2d/navigation_polygon.h"
  35. #include "servers/navigation_server_2d.h"
  36. #endif // NAVIGATION_2D_DISABLED
  37. #include "skeleton_2d.h"
  38. #ifndef NAVIGATION_2D_DISABLED
  39. Callable Polygon2D::_navmesh_source_geometry_parsing_callback;
  40. RID Polygon2D::_navmesh_source_geometry_parser;
  41. #endif // NAVIGATION_2D_DISABLED
  42. #ifdef TOOLS_ENABLED
  43. Dictionary Polygon2D::_edit_get_state() const {
  44. Dictionary state = Node2D::_edit_get_state();
  45. state["offset"] = offset;
  46. return state;
  47. }
  48. void Polygon2D::_edit_set_state(const Dictionary &p_state) {
  49. Node2D::_edit_set_state(p_state);
  50. set_offset(p_state["offset"]);
  51. }
  52. void Polygon2D::_edit_set_pivot(const Point2 &p_pivot) {
  53. set_position(get_transform().xform(p_pivot));
  54. set_offset(get_offset() - p_pivot);
  55. }
  56. Point2 Polygon2D::_edit_get_pivot() const {
  57. return Vector2();
  58. }
  59. bool Polygon2D::_edit_use_pivot() const {
  60. return true;
  61. }
  62. #endif // TOOLS_ENABLED
  63. #ifdef DEBUG_ENABLED
  64. Rect2 Polygon2D::_edit_get_rect() const {
  65. if (rect_cache_dirty) {
  66. int l = polygon.size();
  67. const Vector2 *r = polygon.ptr();
  68. item_rect = Rect2();
  69. for (int i = 0; i < l; i++) {
  70. Vector2 pos = r[i] + offset;
  71. if (i == 0) {
  72. item_rect.position = pos;
  73. } else {
  74. item_rect.expand_to(pos);
  75. }
  76. }
  77. rect_cache_dirty = false;
  78. }
  79. return item_rect;
  80. }
  81. bool Polygon2D::_edit_use_rect() const {
  82. return polygon.size() > 0;
  83. }
  84. bool Polygon2D::_edit_is_selected_on_click(const Point2 &p_point, double p_tolerance) const {
  85. Vector<Vector2> polygon2d = Variant(polygon);
  86. if (internal_vertices > 0) {
  87. polygon2d.resize(polygon2d.size() - internal_vertices);
  88. }
  89. return Geometry2D::is_point_in_polygon(p_point - get_offset(), polygon2d);
  90. }
  91. #endif // DEBUG_ENABLED
  92. void Polygon2D::_validate_property(PropertyInfo &p_property) const {
  93. if (!invert && p_property.name == "invert_border") {
  94. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  95. }
  96. }
  97. void Polygon2D::_skeleton_bone_setup_changed() {
  98. queue_redraw();
  99. }
  100. void Polygon2D::_notification(int p_what) {
  101. if (p_what == NOTIFICATION_TRANSFORM_CHANGED && !Engine::get_singleton()->is_editor_hint()) {
  102. return; // Mesh recreation for NOTIFICATION_TRANSFORM_CHANGED is only needed in editor.
  103. }
  104. switch (p_what) {
  105. case NOTIFICATION_TRANSFORM_CHANGED:
  106. case NOTIFICATION_DRAW: {
  107. if (polygon.size() < 3) {
  108. return;
  109. }
  110. Skeleton2D *skeleton_node = nullptr;
  111. if (has_node(skeleton)) {
  112. skeleton_node = Object::cast_to<Skeleton2D>(get_node(skeleton));
  113. }
  114. ObjectID new_skeleton_id;
  115. if (skeleton_node && !invert && bone_weights.size()) {
  116. RS::get_singleton()->canvas_item_attach_skeleton(get_canvas_item(), skeleton_node->get_skeleton());
  117. new_skeleton_id = skeleton_node->get_instance_id();
  118. } else {
  119. RS::get_singleton()->canvas_item_attach_skeleton(get_canvas_item(), RID());
  120. }
  121. if (new_skeleton_id != current_skeleton_id) {
  122. Object *old_skeleton = ObjectDB::get_instance(current_skeleton_id);
  123. if (old_skeleton) {
  124. old_skeleton->disconnect("bone_setup_changed", callable_mp(this, &Polygon2D::_skeleton_bone_setup_changed));
  125. }
  126. if (skeleton_node) {
  127. skeleton_node->connect("bone_setup_changed", callable_mp(this, &Polygon2D::_skeleton_bone_setup_changed));
  128. }
  129. current_skeleton_id = new_skeleton_id;
  130. }
  131. Vector<Vector2> points;
  132. Vector<Vector2> uvs;
  133. Vector<int> bones;
  134. Vector<float> weights;
  135. int len = polygon.size();
  136. if ((invert || polygons.size() == 0) && internal_vertices > 0) {
  137. //if no polygons are around, internal vertices must not be drawn, else let them be
  138. len -= internal_vertices;
  139. }
  140. if (len <= 0) {
  141. return;
  142. }
  143. points.resize(len);
  144. {
  145. const Vector2 *polyr = polygon.ptr();
  146. for (int i = 0; i < len; i++) {
  147. points.write[i] = polyr[i] + offset;
  148. }
  149. }
  150. if (invert) {
  151. Rect2 bounds;
  152. int highest_idx = -1;
  153. real_t highest_y = -1e20;
  154. real_t sum = 0.0;
  155. for (int i = 0; i < len; i++) {
  156. if (i == 0) {
  157. bounds.position = points[i];
  158. } else {
  159. bounds.expand_to(points[i]);
  160. }
  161. if (points[i].y > highest_y) {
  162. highest_idx = i;
  163. highest_y = points[i].y;
  164. }
  165. int ni = (i + 1) % len;
  166. sum += (points[ni].x - points[i].x) * (points[ni].y + points[i].y);
  167. }
  168. bounds = bounds.grow(invert_border);
  169. Vector2 ep[7] = {
  170. Vector2(points[highest_idx].x, points[highest_idx].y + invert_border),
  171. Vector2(bounds.position + bounds.size),
  172. Vector2(bounds.position + Vector2(bounds.size.x, 0)),
  173. Vector2(bounds.position),
  174. Vector2(bounds.position + Vector2(0, bounds.size.y)),
  175. Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y + invert_border),
  176. Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y),
  177. };
  178. if (sum > 0) {
  179. SWAP(ep[1], ep[4]);
  180. SWAP(ep[2], ep[3]);
  181. SWAP(ep[5], ep[0]);
  182. SWAP(ep[6], points.write[highest_idx]);
  183. }
  184. points.resize(points.size() + 7);
  185. for (int i = points.size() - 1; i >= highest_idx + 7; i--) {
  186. points.write[i] = points[i - 7];
  187. }
  188. for (int i = 0; i < 7; i++) {
  189. points.write[highest_idx + i + 1] = ep[i];
  190. }
  191. len = points.size();
  192. }
  193. if (texture.is_valid()) {
  194. Transform2D texmat(tex_rot, tex_ofs);
  195. texmat.scale(tex_scale);
  196. Size2 tex_size = texture->get_size();
  197. uvs.resize(len);
  198. if (points.size() == uv.size()) {
  199. const Vector2 *uvr = uv.ptr();
  200. for (int i = 0; i < len; i++) {
  201. uvs.write[i] = texmat.xform(uvr[i]) / tex_size;
  202. }
  203. } else {
  204. for (int i = 0; i < len; i++) {
  205. uvs.write[i] = texmat.xform(points[i]) / tex_size;
  206. }
  207. }
  208. }
  209. if (skeleton_node && !invert && bone_weights.size()) {
  210. //a skeleton is set! fill indices and weights
  211. int vc = len;
  212. bones.resize(vc * 4);
  213. weights.resize(vc * 4);
  214. int *bonesw = bones.ptrw();
  215. float *weightsw = weights.ptrw();
  216. for (int i = 0; i < vc * 4; i++) {
  217. bonesw[i] = 0;
  218. weightsw[i] = 0;
  219. }
  220. for (int i = 0; i < bone_weights.size(); i++) {
  221. if (bone_weights[i].weights.size() != points.size()) {
  222. continue; //different number of vertices, sorry not using.
  223. }
  224. if (!skeleton_node->has_node(bone_weights[i].path)) {
  225. continue; //node does not exist
  226. }
  227. Bone2D *bone = Object::cast_to<Bone2D>(skeleton_node->get_node(bone_weights[i].path));
  228. if (!bone) {
  229. continue;
  230. }
  231. int bone_index = bone->get_index_in_skeleton();
  232. const float *r = bone_weights[i].weights.ptr();
  233. for (int j = 0; j < vc; j++) {
  234. if (r[j] == 0.0) {
  235. continue; //weight is unpainted, skip
  236. }
  237. //find an index with a weight
  238. for (int k = 0; k < 4; k++) {
  239. if (weightsw[j * 4 + k] < r[j]) {
  240. //this is less than this weight, insert weight!
  241. for (int l = 3; l > k; l--) {
  242. weightsw[j * 4 + l] = weightsw[j * 4 + l - 1];
  243. bonesw[j * 4 + l] = bonesw[j * 4 + l - 1];
  244. }
  245. weightsw[j * 4 + k] = r[j];
  246. bonesw[j * 4 + k] = bone_index;
  247. break;
  248. }
  249. }
  250. }
  251. }
  252. //normalize the weights
  253. for (int i = 0; i < vc; i++) {
  254. real_t tw = 0.0;
  255. for (int j = 0; j < 4; j++) {
  256. tw += weightsw[i * 4 + j];
  257. }
  258. if (tw == 0) {
  259. continue; //unpainted, do nothing
  260. }
  261. //normalize
  262. for (int j = 0; j < 4; j++) {
  263. weightsw[i * 4 + j] /= tw;
  264. }
  265. }
  266. }
  267. Vector<Color> colors;
  268. colors.resize(len);
  269. if (vertex_colors.size() == points.size()) {
  270. const Color *color_r = vertex_colors.ptr();
  271. for (int i = 0; i < len; i++) {
  272. colors.write[i] = color_r[i];
  273. }
  274. } else {
  275. for (int i = 0; i < len; i++) {
  276. colors.write[i] = color;
  277. }
  278. }
  279. Vector<int> index_array;
  280. if (invert || polygons.size() == 0) {
  281. index_array = Geometry2D::triangulate_polygon(points);
  282. } else {
  283. //draw individual polygons
  284. for (int i = 0; i < polygons.size(); i++) {
  285. Vector<int> src_indices = polygons[i];
  286. int ic = src_indices.size();
  287. if (ic < 3) {
  288. continue;
  289. }
  290. const int *r = src_indices.ptr();
  291. Vector<Vector2> tmp_points;
  292. tmp_points.resize(ic);
  293. for (int j = 0; j < ic; j++) {
  294. int idx = r[j];
  295. ERR_CONTINUE(idx < 0 || idx >= points.size());
  296. tmp_points.write[j] = points[r[j]];
  297. }
  298. Vector<int> indices = Geometry2D::triangulate_polygon(tmp_points);
  299. int ic2 = indices.size();
  300. const int *r2 = indices.ptr();
  301. int bic = index_array.size();
  302. index_array.resize(bic + ic2);
  303. int *w2 = index_array.ptrw();
  304. for (int j = 0; j < ic2; j++) {
  305. w2[j + bic] = r[r2[j]];
  306. }
  307. }
  308. }
  309. RS::get_singleton()->mesh_clear(mesh);
  310. if (index_array.size()) {
  311. Array arr;
  312. arr.resize(RS::ARRAY_MAX);
  313. arr[RS::ARRAY_VERTEX] = points;
  314. if (uvs.size() == points.size()) {
  315. arr[RS::ARRAY_TEX_UV] = uvs;
  316. }
  317. if (colors.size() == points.size()) {
  318. arr[RS::ARRAY_COLOR] = colors;
  319. }
  320. if (bones.size() == points.size() * 4) {
  321. arr[RS::ARRAY_BONES] = bones;
  322. arr[RS::ARRAY_WEIGHTS] = weights;
  323. }
  324. arr[RS::ARRAY_INDEX] = index_array;
  325. RS::SurfaceData sd;
  326. if (skeleton_node) {
  327. // Compute transform between mesh and skeleton for runtime AABB compute.
  328. const Transform2D mesh_transform = get_global_transform();
  329. const Transform2D skeleton_transform = skeleton_node->get_global_transform();
  330. const Transform2D mesh_to_sk2d = skeleton_transform.affine_inverse() * mesh_transform;
  331. // Convert 2d transform to 3d.
  332. sd.mesh_to_skeleton_xform.basis.rows[0][0] = mesh_to_sk2d.columns[0][0];
  333. sd.mesh_to_skeleton_xform.basis.rows[1][0] = mesh_to_sk2d.columns[0][1];
  334. sd.mesh_to_skeleton_xform.origin.x = mesh_to_sk2d.get_origin().x;
  335. sd.mesh_to_skeleton_xform.basis.rows[0][1] = mesh_to_sk2d.columns[1][0];
  336. sd.mesh_to_skeleton_xform.basis.rows[1][1] = mesh_to_sk2d.columns[1][1];
  337. sd.mesh_to_skeleton_xform.origin.y = mesh_to_sk2d.get_origin().y;
  338. }
  339. Error err = RS::get_singleton()->mesh_create_surface_data_from_arrays(&sd, RS::PRIMITIVE_TRIANGLES, arr, Array(), Dictionary(), RS::ARRAY_FLAG_USE_2D_VERTICES);
  340. if (err != OK) {
  341. return;
  342. }
  343. RS::get_singleton()->mesh_add_surface(mesh, sd);
  344. RS::get_singleton()->canvas_item_add_mesh(get_canvas_item(), mesh, Transform2D(), Color(1, 1, 1), texture.is_valid() ? texture->get_rid() : RID());
  345. }
  346. } break;
  347. }
  348. }
  349. void Polygon2D::set_polygon(const Vector<Vector2> &p_polygon) {
  350. polygon = p_polygon;
  351. rect_cache_dirty = true;
  352. queue_redraw();
  353. }
  354. Vector<Vector2> Polygon2D::get_polygon() const {
  355. return polygon;
  356. }
  357. void Polygon2D::set_internal_vertex_count(int p_count) {
  358. internal_vertices = p_count;
  359. }
  360. int Polygon2D::get_internal_vertex_count() const {
  361. return internal_vertices;
  362. }
  363. void Polygon2D::set_uv(const Vector<Vector2> &p_uv) {
  364. uv = p_uv;
  365. queue_redraw();
  366. }
  367. Vector<Vector2> Polygon2D::get_uv() const {
  368. return uv;
  369. }
  370. void Polygon2D::set_polygons(const Array &p_polygons) {
  371. polygons = p_polygons;
  372. queue_redraw();
  373. }
  374. Array Polygon2D::get_polygons() const {
  375. return polygons;
  376. }
  377. void Polygon2D::set_color(const Color &p_color) {
  378. color = p_color;
  379. queue_redraw();
  380. }
  381. Color Polygon2D::get_color() const {
  382. return color;
  383. }
  384. void Polygon2D::set_vertex_colors(const Vector<Color> &p_colors) {
  385. vertex_colors = p_colors;
  386. queue_redraw();
  387. }
  388. Vector<Color> Polygon2D::get_vertex_colors() const {
  389. return vertex_colors;
  390. }
  391. void Polygon2D::set_texture(const Ref<Texture2D> &p_texture) {
  392. texture = p_texture;
  393. queue_redraw();
  394. }
  395. Ref<Texture2D> Polygon2D::get_texture() const {
  396. return texture;
  397. }
  398. void Polygon2D::set_texture_offset(const Vector2 &p_offset) {
  399. tex_ofs = p_offset;
  400. queue_redraw();
  401. }
  402. Vector2 Polygon2D::get_texture_offset() const {
  403. return tex_ofs;
  404. }
  405. void Polygon2D::set_texture_rotation(real_t p_rot) {
  406. tex_rot = p_rot;
  407. queue_redraw();
  408. }
  409. real_t Polygon2D::get_texture_rotation() const {
  410. return tex_rot;
  411. }
  412. void Polygon2D::set_texture_scale(const Size2 &p_scale) {
  413. tex_scale = p_scale;
  414. queue_redraw();
  415. }
  416. Size2 Polygon2D::get_texture_scale() const {
  417. return tex_scale;
  418. }
  419. void Polygon2D::set_invert(bool p_invert) {
  420. invert = p_invert;
  421. queue_redraw();
  422. notify_property_list_changed();
  423. }
  424. bool Polygon2D::get_invert() const {
  425. return invert;
  426. }
  427. void Polygon2D::set_antialiased(bool p_antialiased) {
  428. antialiased = p_antialiased;
  429. queue_redraw();
  430. }
  431. bool Polygon2D::get_antialiased() const {
  432. return antialiased;
  433. }
  434. void Polygon2D::set_invert_border(real_t p_invert_border) {
  435. invert_border = p_invert_border;
  436. queue_redraw();
  437. }
  438. real_t Polygon2D::get_invert_border() const {
  439. return invert_border;
  440. }
  441. void Polygon2D::set_offset(const Vector2 &p_offset) {
  442. offset = p_offset;
  443. rect_cache_dirty = true;
  444. queue_redraw();
  445. }
  446. Vector2 Polygon2D::get_offset() const {
  447. return offset;
  448. }
  449. void Polygon2D::add_bone(const NodePath &p_path, const Vector<float> &p_weights) {
  450. Bone bone;
  451. bone.path = p_path;
  452. bone.weights = p_weights;
  453. bone_weights.push_back(bone);
  454. }
  455. int Polygon2D::get_bone_count() const {
  456. return bone_weights.size();
  457. }
  458. NodePath Polygon2D::get_bone_path(int p_index) const {
  459. ERR_FAIL_INDEX_V(p_index, bone_weights.size(), NodePath());
  460. return bone_weights[p_index].path;
  461. }
  462. Vector<float> Polygon2D::get_bone_weights(int p_index) const {
  463. ERR_FAIL_INDEX_V(p_index, bone_weights.size(), Vector<float>());
  464. return bone_weights[p_index].weights;
  465. }
  466. void Polygon2D::erase_bone(int p_idx) {
  467. ERR_FAIL_INDEX(p_idx, bone_weights.size());
  468. bone_weights.remove_at(p_idx);
  469. }
  470. void Polygon2D::clear_bones() {
  471. bone_weights.clear();
  472. }
  473. void Polygon2D::set_bone_weights(int p_index, const Vector<float> &p_weights) {
  474. ERR_FAIL_INDEX(p_index, bone_weights.size());
  475. bone_weights.write[p_index].weights = p_weights;
  476. queue_redraw();
  477. }
  478. void Polygon2D::set_bone_path(int p_index, const NodePath &p_path) {
  479. ERR_FAIL_INDEX(p_index, bone_weights.size());
  480. bone_weights.write[p_index].path = p_path;
  481. queue_redraw();
  482. }
  483. Array Polygon2D::_get_bones() const {
  484. Array bones;
  485. for (int i = 0; i < get_bone_count(); i++) {
  486. // Convert path property to String to avoid errors due to invalid node path in editor,
  487. // because it's relative to the Skeleton2D node and not Polygon2D.
  488. bones.push_back(String(get_bone_path(i)));
  489. bones.push_back(get_bone_weights(i));
  490. }
  491. return bones;
  492. }
  493. void Polygon2D::_set_bones(const Array &p_bones) {
  494. ERR_FAIL_COND(p_bones.size() & 1);
  495. clear_bones();
  496. for (int i = 0; i < p_bones.size(); i += 2) {
  497. // Convert back from String to NodePath.
  498. add_bone(NodePath(p_bones[i]), p_bones[i + 1]);
  499. }
  500. }
  501. void Polygon2D::set_skeleton(const NodePath &p_skeleton) {
  502. if (skeleton == p_skeleton) {
  503. return;
  504. }
  505. skeleton = p_skeleton;
  506. queue_redraw();
  507. }
  508. NodePath Polygon2D::get_skeleton() const {
  509. return skeleton;
  510. }
  511. #ifndef NAVIGATION_2D_DISABLED
  512. void Polygon2D::navmesh_parse_init() {
  513. ERR_FAIL_NULL(NavigationServer2D::get_singleton());
  514. if (!_navmesh_source_geometry_parser.is_valid()) {
  515. _navmesh_source_geometry_parsing_callback = callable_mp_static(&Polygon2D::navmesh_parse_source_geometry);
  516. _navmesh_source_geometry_parser = NavigationServer2D::get_singleton()->source_geometry_parser_create();
  517. NavigationServer2D::get_singleton()->source_geometry_parser_set_callback(_navmesh_source_geometry_parser, _navmesh_source_geometry_parsing_callback);
  518. }
  519. }
  520. void Polygon2D::navmesh_parse_source_geometry(const Ref<NavigationPolygon> &p_navigation_mesh, Ref<NavigationMeshSourceGeometryData2D> p_source_geometry_data, Node *p_node) {
  521. Polygon2D *polygon_2d = Object::cast_to<Polygon2D>(p_node);
  522. if (polygon_2d == nullptr) {
  523. return;
  524. }
  525. NavigationPolygon::ParsedGeometryType parsed_geometry_type = p_navigation_mesh->get_parsed_geometry_type();
  526. if (parsed_geometry_type == NavigationPolygon::PARSED_GEOMETRY_MESH_INSTANCES || parsed_geometry_type == NavigationPolygon::PARSED_GEOMETRY_BOTH) {
  527. const Transform2D polygon_2d_xform = p_source_geometry_data->root_node_transform * polygon_2d->get_global_transform();
  528. Vector<Vector2> shape_outline = polygon_2d->get_polygon();
  529. for (int i = 0; i < shape_outline.size(); i++) {
  530. shape_outline.write[i] = polygon_2d_xform.xform(shape_outline[i]);
  531. }
  532. p_source_geometry_data->add_obstruction_outline(shape_outline);
  533. }
  534. }
  535. #endif // NAVIGATION_2D_DISABLED
  536. void Polygon2D::_bind_methods() {
  537. ClassDB::bind_method(D_METHOD("set_polygon", "polygon"), &Polygon2D::set_polygon);
  538. ClassDB::bind_method(D_METHOD("get_polygon"), &Polygon2D::get_polygon);
  539. ClassDB::bind_method(D_METHOD("set_uv", "uv"), &Polygon2D::set_uv);
  540. ClassDB::bind_method(D_METHOD("get_uv"), &Polygon2D::get_uv);
  541. ClassDB::bind_method(D_METHOD("set_color", "color"), &Polygon2D::set_color);
  542. ClassDB::bind_method(D_METHOD("get_color"), &Polygon2D::get_color);
  543. ClassDB::bind_method(D_METHOD("set_polygons", "polygons"), &Polygon2D::set_polygons);
  544. ClassDB::bind_method(D_METHOD("get_polygons"), &Polygon2D::get_polygons);
  545. ClassDB::bind_method(D_METHOD("set_vertex_colors", "vertex_colors"), &Polygon2D::set_vertex_colors);
  546. ClassDB::bind_method(D_METHOD("get_vertex_colors"), &Polygon2D::get_vertex_colors);
  547. ClassDB::bind_method(D_METHOD("set_texture", "texture"), &Polygon2D::set_texture);
  548. ClassDB::bind_method(D_METHOD("get_texture"), &Polygon2D::get_texture);
  549. ClassDB::bind_method(D_METHOD("set_texture_offset", "texture_offset"), &Polygon2D::set_texture_offset);
  550. ClassDB::bind_method(D_METHOD("get_texture_offset"), &Polygon2D::get_texture_offset);
  551. ClassDB::bind_method(D_METHOD("set_texture_rotation", "texture_rotation"), &Polygon2D::set_texture_rotation);
  552. ClassDB::bind_method(D_METHOD("get_texture_rotation"), &Polygon2D::get_texture_rotation);
  553. ClassDB::bind_method(D_METHOD("set_texture_scale", "texture_scale"), &Polygon2D::set_texture_scale);
  554. ClassDB::bind_method(D_METHOD("get_texture_scale"), &Polygon2D::get_texture_scale);
  555. ClassDB::bind_method(D_METHOD("set_invert_enabled", "invert"), &Polygon2D::set_invert);
  556. ClassDB::bind_method(D_METHOD("get_invert_enabled"), &Polygon2D::get_invert);
  557. ClassDB::bind_method(D_METHOD("set_antialiased", "antialiased"), &Polygon2D::set_antialiased);
  558. ClassDB::bind_method(D_METHOD("get_antialiased"), &Polygon2D::get_antialiased);
  559. ClassDB::bind_method(D_METHOD("set_invert_border", "invert_border"), &Polygon2D::set_invert_border);
  560. ClassDB::bind_method(D_METHOD("get_invert_border"), &Polygon2D::get_invert_border);
  561. ClassDB::bind_method(D_METHOD("set_offset", "offset"), &Polygon2D::set_offset);
  562. ClassDB::bind_method(D_METHOD("get_offset"), &Polygon2D::get_offset);
  563. ClassDB::bind_method(D_METHOD("add_bone", "path", "weights"), &Polygon2D::add_bone);
  564. ClassDB::bind_method(D_METHOD("get_bone_count"), &Polygon2D::get_bone_count);
  565. ClassDB::bind_method(D_METHOD("get_bone_path", "index"), &Polygon2D::get_bone_path);
  566. ClassDB::bind_method(D_METHOD("get_bone_weights", "index"), &Polygon2D::get_bone_weights);
  567. ClassDB::bind_method(D_METHOD("erase_bone", "index"), &Polygon2D::erase_bone);
  568. ClassDB::bind_method(D_METHOD("clear_bones"), &Polygon2D::clear_bones);
  569. ClassDB::bind_method(D_METHOD("set_bone_path", "index", "path"), &Polygon2D::set_bone_path);
  570. ClassDB::bind_method(D_METHOD("set_bone_weights", "index", "weights"), &Polygon2D::set_bone_weights);
  571. ClassDB::bind_method(D_METHOD("set_skeleton", "skeleton"), &Polygon2D::set_skeleton);
  572. ClassDB::bind_method(D_METHOD("get_skeleton"), &Polygon2D::get_skeleton);
  573. ClassDB::bind_method(D_METHOD("set_internal_vertex_count", "internal_vertex_count"), &Polygon2D::set_internal_vertex_count);
  574. ClassDB::bind_method(D_METHOD("get_internal_vertex_count"), &Polygon2D::get_internal_vertex_count);
  575. ClassDB::bind_method(D_METHOD("_set_bones", "bones"), &Polygon2D::_set_bones);
  576. ClassDB::bind_method(D_METHOD("_get_bones"), &Polygon2D::_get_bones);
  577. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "color"), "set_color", "get_color");
  578. ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "offset"), "set_offset", "get_offset");
  579. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "antialiased"), "set_antialiased", "get_antialiased");
  580. ADD_GROUP("Texture", "texture_");
  581. ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture");
  582. ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "texture_offset", PROPERTY_HINT_NONE, "suffix:px"), "set_texture_offset", "get_texture_offset");
  583. ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "texture_scale", PROPERTY_HINT_LINK), "set_texture_scale", "get_texture_scale");
  584. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "texture_rotation", PROPERTY_HINT_RANGE, "-360,360,0.1,or_less,or_greater,radians_as_degrees"), "set_texture_rotation", "get_texture_rotation");
  585. ADD_GROUP("Skeleton", "");
  586. ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "skeleton", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Skeleton2D"), "set_skeleton", "get_skeleton");
  587. ADD_GROUP("Invert", "invert_");
  588. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "invert_enabled"), "set_invert_enabled", "get_invert_enabled");
  589. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "invert_border", PROPERTY_HINT_RANGE, "0.1,16384,0.1,suffix:px"), "set_invert_border", "get_invert_border");
  590. ADD_GROUP("Data", "");
  591. ADD_PROPERTY(PropertyInfo(Variant::PACKED_VECTOR2_ARRAY, "polygon"), "set_polygon", "get_polygon");
  592. ADD_PROPERTY(PropertyInfo(Variant::PACKED_VECTOR2_ARRAY, "uv"), "set_uv", "get_uv");
  593. ADD_PROPERTY(PropertyInfo(Variant::PACKED_COLOR_ARRAY, "vertex_colors"), "set_vertex_colors", "get_vertex_colors");
  594. ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "polygons"), "set_polygons", "get_polygons");
  595. ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "bones", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_bones", "_get_bones");
  596. ADD_PROPERTY(PropertyInfo(Variant::INT, "internal_vertex_count", PROPERTY_HINT_RANGE, "0,1000"), "set_internal_vertex_count", "get_internal_vertex_count");
  597. }
  598. Polygon2D::Polygon2D() {
  599. mesh = RS::get_singleton()->mesh_create();
  600. }
  601. Polygon2D::~Polygon2D() {
  602. // This will free the internally-allocated mesh instance, if allocated.
  603. ERR_FAIL_NULL(RenderingServer::get_singleton());
  604. RS::get_singleton()->canvas_item_attach_skeleton(get_canvas_item(), RID());
  605. RS::get_singleton()->free(mesh);
  606. }