asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/editor/plugins/tile_set_editor_plugin.cpp

3685 lines
144 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* tile_set_editor_plugin.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-13 09:45:09 +01:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "tile_set_editor_plugin.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 08:04:19 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
#include "core/os/input.h"
#include "core/os/keyboard.h"
Cleans up headers included in editor_node.h
2019-12-24 08:17:23 +01:00
#include "editor/editor_scale.h"
Implement auto-tiling
2017-10-22 03:42:23 +02:00
#include "editor/plugins/canvas_item_editor_plugin.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "scene/2d/physics_body_2d.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
#include "scene/2d/sprite.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 08:04:19 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
void TileSetEditor::edit(const Ref<TileSet> &p_tileset) {
tileset = p_tileset;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->add_change_receptor(this);
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list->clear();
texture_map.clear();
update_texture_list();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
for (int i = 0; i < p_node->get_child_count(); i++) {
Node *child = p_node->get_child(i);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
if (!Object::cast_to<Sprite>(child)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (child->get_child_count() > 0) {
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
_import_node(child, p_library);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
continue;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
Sprite *mi = Object::cast_to<Sprite>(child);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Ref<Texture> texture = mi->get_texture();
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 17:15:50 +02:00
Ref<Texture> normal_map = mi->get_normal_map();
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
Ref<ShaderMaterial> material = mi->get_material();
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (texture.is_null()) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
int id = p_library->find_tile_by_name(mi->get_name());
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (id < 0) {
id = p_library->get_last_unused_tile_id();
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
p_library->create_tile(id);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_name(id, mi->get_name());
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_texture(id, texture);
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 17:15:50 +02:00
p_library->tile_set_normal_map(id, normal_map);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_material(id, material);
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_modulate(id, mi->get_modulate());
Add modulate (color) to TileSet tiles
2016-11-30 14:33:39 +01:00
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Vector2 phys_offset;
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
Size2 s;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
if (mi->is_region()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
s = mi->get_region_rect().size;
p_library->tile_set_region(id, mi->get_region_rect());
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
} else {
const int frame = mi->get_frame();
const int hframes = mi->get_hframes();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
s = texture->get_size() / Size2(hframes, mi->get_vframes());
p_library->tile_set_region(id, Rect2(Vector2(frame % hframes, frame / hframes) * s, s));
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
if (mi->is_centered()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
phys_offset += -s / 2;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
Vector<TileSet::ShapeData> collisions;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Ref<NavigationPolygon> nav_poly;
Ref<OccluderPolygon2D> occluder;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
bool found_collisions = false;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int j = 0; j < mi->get_child_count(); j++) {
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Node *child2 = mi->get_child(j);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (Object::cast_to<NavigationPolygonInstance>(child2)) {
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
nav_poly = Object::cast_to<NavigationPolygonInstance>(child2)->get_navigation_polygon();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (Object::cast_to<LightOccluder2D>(child2)) {
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
occluder = Object::cast_to<LightOccluder2D>(child2)->get_occluder_polygon();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!Object::cast_to<StaticBody2D>(child2)) {
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
found_collisions = true;
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
StaticBody2D *sb = Object::cast_to<StaticBody2D>(child2);
-Trigger shapes removed in 2D, they became obsolete long ago when areas could detect their own overlap -Added ability to disable individual collisionshape/polygon -Moved One Way Collision to shape, allowing more flexibility -Changed internals of CollisionObject, shapes are generated from child nodes on the fly, not stored inside any longer. -Modifying a CollisionPolygon2D on the fly now works, it can even be animated. Will port this to 3D once well tested. Have fun!
2017-06-24 04:30:43 +02:00
List<uint32_t> shapes;
sb->get_shape_owners(&shapes);
for (List<uint32_t>::Element *E = shapes.front(); E; E = E->next()) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (sb->is_shape_owner_disabled(E->get())) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine
2021-05-04 14:28:27 +02:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
-Trigger shapes removed in 2D, they became obsolete long ago when areas could detect their own overlap -Added ability to disable individual collisionshape/polygon -Moved One Way Collision to shape, allowing more flexibility -Changed internals of CollisionObject, shapes are generated from child nodes on the fly, not stored inside any longer. -Modifying a CollisionPolygon2D on the fly now works, it can even be animated. Will port this to 3D once well tested. Have fun!
2017-06-24 04:30:43 +02:00
Fix bugs related to bad handling of rotated/translated shapes in tilemap Fixup #18529 and #12870
2018-06-03 15:32:23 +02:00
Transform2D shape_transform = sb->get_transform() * sb->shape_owner_get_transform(E->get());
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-25 20:47:30 +02:00
bool one_way = sb->is_shape_owner_one_way_collision_enabled(E->get());
Fix bugs related to bad handling of rotated/translated shapes in tilemap Fixup #18529 and #12870
2018-06-03 15:32:23 +02:00
shape_transform[2] -= phys_offset;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
-Trigger shapes removed in 2D, they became obsolete long ago when areas could detect their own overlap -Added ability to disable individual collisionshape/polygon -Moved One Way Collision to shape, allowing more flexibility -Changed internals of CollisionObject, shapes are generated from child nodes on the fly, not stored inside any longer. -Modifying a CollisionPolygon2D on the fly now works, it can even be animated. Will port this to 3D once well tested. Have fun!
2017-06-24 04:30:43 +02:00
for (int k = 0; k < sb->shape_owner_get_shape_count(E->get()); k++) {
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
Ref<Shape2D> shape = sb->shape_owner_get_shape(E->get(), k);
TileSet::ShapeData shape_data;
shape_data.shape = shape;
shape_data.shape_transform = shape_transform;
shape_data.one_way_collision = one_way;
collisions.push_back(shape_data);
Add all collision shapes to a tile when converting scenes to TileSets
2015-10-25 23:13:46 +01:00
}
heck
2014-04-19 21:46:52 +02:00
}
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
if (found_collisions) {
p_library->tile_set_shapes(id, collisions);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_texture_offset(id, mi->get_offset());
p_library->tile_set_navigation_polygon(id, nav_poly);
p_library->tile_set_light_occluder(id, occluder);
p_library->tile_set_occluder_offset(id, -phys_offset);
p_library->tile_set_navigation_polygon_offset(id, -phys_offset);
Adds z-index properties to TileSets.
2018-02-17 11:58:07 +01:00
p_library->tile_set_z_index(id, mi->get_z_index());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
}
Updated function argument names
2017-08-12 18:52:50 +02:00
void TileSetEditor::_import_scene(Node *p_scene, Ref<TileSet> p_library, bool p_merge) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!p_merge) {
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
p_library->clear();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
Updated function argument names
2017-08-12 18:52:50 +02:00
_import_node(p_scene, p_library);
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
void TileSetEditor::_undo_redo_import_scene(Node *p_scene, bool p_merge) {
_import_scene(p_scene, tileset, p_merge);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Error TileSetEditor::update_library_file(Node *p_base_scene, Ref<TileSet> ml, bool p_merge) {
_import_scene(p_base_scene, ml, p_merge);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return OK;
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
Variant TileSetEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
return false;
}
bool TileSetEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
Dictionary d = p_data;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!d.has("type")) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (d.has("from") && (Object *)(d["from"]) == texture_list) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
if (String(d["type"]) == "resource" && d.has("resource")) {
RES r = d["resource"];
Ref<Texture> texture = r;
if (texture.is_valid()) {
return true;
}
}
if (String(d["type"]) == "files") {
Vector<String> files = d["files"];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (files.size() == 0) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
for (int i = 0; i < files.size(); i++) {
String file = files[i];
String ftype = EditorFileSystem::get_singleton()->get_file_type(file);
if (!ClassDB::is_parent_class(ftype, "Texture")) {
return false;
}
}
return true;
}
return false;
}
void TileSetEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!can_drop_data_fw(p_point, p_data, p_from)) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
Dictionary d = p_data;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!d.has("type")) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
if (String(d["type"]) == "resource" && d.has("resource")) {
RES r = d["resource"];
Ref<Texture> texture = r;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (texture.is_valid()) {
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
add_texture(texture);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
if (texture_list->get_item_count() > 0) {
update_texture_list_icon();
texture_list->select(texture_list->get_item_count() - 1);
_on_texture_list_selected(texture_list->get_item_count() - 1);
}
}
if (String(d["type"]) == "files") {
PoolVector<String> files = d["files"];
_on_textures_added(files);
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void TileSetEditor::_bind_methods() {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_undo_redo_import_scene", &TileSetEditor::_undo_redo_import_scene);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_tileset_toolbar_button_pressed", &TileSetEditor::_on_tileset_toolbar_button_pressed);
ClassDB::bind_method("_on_textures_added", &TileSetEditor::_on_textures_added);
ClassDB::bind_method("_on_tileset_toolbar_confirm", &TileSetEditor::_on_tileset_toolbar_confirm);
ClassDB::bind_method("_on_texture_list_selected", &TileSetEditor::_on_texture_list_selected);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_edit_mode_changed", &TileSetEditor::_on_edit_mode_changed);
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
ClassDB::bind_method("_on_scroll_container_input", &TileSetEditor::_on_scroll_container_input);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_workspace_mode_changed", &TileSetEditor::_on_workspace_mode_changed);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
ClassDB::bind_method("_on_workspace_overlay_draw", &TileSetEditor::_on_workspace_overlay_draw);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_workspace_process", &TileSetEditor::_on_workspace_process);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_workspace_draw", &TileSetEditor::_on_workspace_draw);
ClassDB::bind_method("_on_workspace_input", &TileSetEditor::_on_workspace_input);
ClassDB::bind_method("_on_tool_clicked", &TileSetEditor::_on_tool_clicked);
ClassDB::bind_method("_on_priority_changed", &TileSetEditor::_on_priority_changed);
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
ClassDB::bind_method("_on_z_index_changed", &TileSetEditor::_on_z_index_changed);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_grid_snap_toggled", &TileSetEditor::_on_grid_snap_toggled);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_set_snap_step", &TileSetEditor::_set_snap_step);
ClassDB::bind_method("_set_snap_off", &TileSetEditor::_set_snap_off);
ClassDB::bind_method("_set_snap_sep", &TileSetEditor::_set_snap_sep);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_validate_current_tile_id", &TileSetEditor::_validate_current_tile_id);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
ClassDB::bind_method("_zoom_in", &TileSetEditor::_zoom_in);
ClassDB::bind_method("_zoom_out", &TileSetEditor::_zoom_out);
ClassDB::bind_method("_zoom_reset", &TileSetEditor::_zoom_reset);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_select_edited_shape_coord", &TileSetEditor::_select_edited_shape_coord);
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
ClassDB::bind_method("_sort_tiles", &TileSetEditor::_sort_tiles);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
ClassDB::bind_method(D_METHOD("get_drag_data_fw"), &TileSetEditor::get_drag_data_fw);
ClassDB::bind_method(D_METHOD("can_drop_data_fw"), &TileSetEditor::can_drop_data_fw);
ClassDB::bind_method(D_METHOD("drop_data_fw"), &TileSetEditor::drop_data_fw);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("edit", &TileSetEditor::edit);
ClassDB::bind_method("add_texture", &TileSetEditor::add_texture);
ClassDB::bind_method("remove_texture", &TileSetEditor::remove_texture);
ClassDB::bind_method("update_texture_list_icon", &TileSetEditor::update_texture_list_icon);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
ClassDB::bind_method("update_workspace_minsize", &TileSetEditor::update_workspace_minsize);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_notification(int p_what) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
switch (p_what) {
case NOTIFICATION_READY: {
add_constant_override("autohide", 1); // Fixes the dragger always showing up.
} break;
case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: {
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_icon(get_icon("ToolAddNode", "EditorIcons"));
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_icon(get_icon("Remove", "EditorIcons"));
tileset_toolbar_tools->set_icon(get_icon("Tools", "EditorIcons"));
tool_workspacemode[WORKSPACE_EDIT]->set_icon(get_icon("Edit", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_SINGLE]->set_icon(get_icon("AddSingleTile", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_AUTOTILE]->set_icon(get_icon("AddAutotile", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_ATLAS]->set_icon(get_icon("AddAtlasTile", "EditorIcons"));
tools[TOOL_SELECT]->set_icon(get_icon("ToolSelect", "EditorIcons"));
Fix icons for tile bitmask copy & paste buttons
2022-03-25 04:11:27 +01:00
tools[BITMASK_COPY]->set_icon(get_icon("ActionCopy", "EditorIcons"));
tools[BITMASK_PASTE]->set_icon(get_icon("ActionPaste", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_CLEAR]->set_icon(get_icon("Clear", "EditorIcons"));
tools[SHAPE_NEW_POLYGON]->set_icon(get_icon("CollisionPolygon2D", "EditorIcons"));
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->set_icon(get_icon("CollisionShape2D", "EditorIcons"));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_PREVIOUS]->set_icon(get_icon("ArrowLeft", "EditorIcons"));
tools[SELECT_NEXT]->set_icon(get_icon("ArrowRight", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_icon(get_icon("Remove", "EditorIcons"));
tools[SHAPE_KEEP_INSIDE_TILE]->set_icon(get_icon("Snap", "EditorIcons"));
tools[TOOL_GRID_SNAP]->set_icon(get_icon("SnapGrid", "EditorIcons"));
tools[ZOOM_OUT]->set_icon(get_icon("ZoomLess", "EditorIcons"));
tools[ZOOM_1]->set_icon(get_icon("ZoomReset", "EditorIcons"));
tools[ZOOM_IN]->set_icon(get_icon("ZoomMore", "EditorIcons"));
tools[VISIBLE_INFO]->set_icon(get_icon("InformationSign", "EditorIcons"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_update_toggle_shape_button();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[EDITMODE_REGION]->set_icon(get_icon("RegionEdit", "EditorIcons"));
tool_editmode[EDITMODE_COLLISION]->set_icon(get_icon("StaticBody2D", "EditorIcons"));
tool_editmode[EDITMODE_OCCLUSION]->set_icon(get_icon("LightOccluder2D", "EditorIcons"));
tool_editmode[EDITMODE_NAVIGATION]->set_icon(get_icon("Navigation2D", "EditorIcons"));
tool_editmode[EDITMODE_BITMASK]->set_icon(get_icon("PackedDataContainer", "EditorIcons"));
tool_editmode[EDITMODE_PRIORITY]->set_icon(get_icon("MaterialPreviewLight1", "EditorIcons"));
tool_editmode[EDITMODE_ICON]->set_icon(get_icon("LargeTexture", "EditorIcons"));
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
tool_editmode[EDITMODE_Z_INDEX]->set_icon(get_icon("Sort", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
scroll->add_style_override("bg", get_stylebox("bg", "Tree"));
} break;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
TileSetEditor::TileSetEditor(EditorNode *p_editor) {
editor = p_editor;
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02:00
undo_redo = EditorNode::get_undo_redo();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
current_tile = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
VBoxContainer *left_container = memnew(VBoxContainer);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
add_child(left_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list = memnew(ItemList);
left_container->add_child(texture_list);
texture_list->set_v_size_flags(SIZE_EXPAND_FILL);
texture_list->set_custom_minimum_size(Size2(200, 0));
texture_list->connect("item_selected", this, "_on_texture_list_selected");
Added drag and drop to the tileset plugin.
2019-08-26 11:15:19 +02:00
texture_list->set_drag_forwarding(this);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
HBoxContainer *tileset_toolbar_container = memnew(HBoxContainer);
left_container->add_child(tileset_toolbar_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->connect("pressed", this, "_on_tileset_toolbar_button_pressed", varray(TOOL_TILESET_ADD_TEXTURE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_tooltip(TTR("Add Texture(s) to TileSet."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->connect("pressed", this, "_on_tileset_toolbar_button_pressed", varray(TOOL_TILESET_REMOVE_TEXTURE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_tooltip(TTR("Remove selected Texture from TileSet."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
Control *toolbar_separator = memnew(Control);
toolbar_separator->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tileset_toolbar_container->add_child(toolbar_separator);
tileset_toolbar_tools = memnew(MenuButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_tools->set_text(TTR("Tools"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_tools->get_popup()->add_item(TTR("Create from Scene"), TOOL_TILESET_CREATE_SCENE);
tileset_toolbar_tools->get_popup()->add_item(TTR("Merge from Scene"), TOOL_TILESET_MERGE_SCENE);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_tools->get_popup()->connect("id_pressed", this, "_on_tileset_toolbar_button_pressed");
tileset_toolbar_container->add_child(tileset_toolbar_tools);
//---------------
VBoxContainer *right_container = memnew(VBoxContainer);
right_container->set_v_size_flags(SIZE_EXPAND_FILL);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
add_child(right_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
dragging_point = -1;
creating_shape = false;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
snap_step = Vector2(32, 32);
New TileSet Editor
2018-07-29 23:54:12 +02:00
snap_offset = WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
set_custom_minimum_size(Size2(0, 150));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
VBoxContainer *main_vb = memnew(VBoxContainer);
New TileSet Editor
2018-07-29 23:54:12 +02:00
right_container->add_child(main_vb);
main_vb->set_v_size_flags(SIZE_EXPAND_FILL);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
HBoxContainer *tool_hb = memnew(HBoxContainer);
Ref<ButtonGroup> g(memnew(ButtonGroup));
Makes more editor strings translatable * "Add" button text in Groups Editor * "Receiver Method" in Connect Signal Dialog * "Play Mode" in Animation State Machine Editor * "Mesh Library" button text in Mesh Library editor plugin * Compose Array node button texts in Visual Script * Various button texts in TileSet Editor * Various Run Script errors
2019-12-21 07:57:15 +01:00
String workspace_label[WORKSPACE_MODE_MAX] = {
TTR("Edit"),
TTR("New Single Tile"),
TTR("New Autotile"),
TTR("New Atlas")
};
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (int i = 0; i < (int)WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i] = memnew(Button);
Makes more editor strings translatable * "Add" button text in Groups Editor * "Receiver Method" in Connect Signal Dialog * "Play Mode" in Animation State Machine Editor * "Mesh Library" button text in Mesh Library editor plugin * Compose Array node button texts in Visual Script * Various button texts in TileSet Editor * Various Run Script errors
2019-12-21 07:57:15 +01:00
tool_workspacemode[i]->set_text(workspace_label[i]);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[i]->set_toggle_mode(true);
tool_workspacemode[i]->set_button_group(g);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_workspacemode[i]->connect("pressed", this, "_on_workspace_mode_changed", varray(i));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_hb->add_child(tool_workspacemode[i]);
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Control *spacer = memnew(Control);
spacer->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tool_hb->add_child(spacer);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_hb->move_child(spacer, WORKSPACE_CREATE_SINGLE);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_NEXT] = memnew(ToolButton);
tool_hb->add_child(tools[SELECT_NEXT]);
tool_hb->move_child(tools[SELECT_NEXT], WORKSPACE_CREATE_SINGLE);
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_shortcut(ED_SHORTCUT("tileset_editor/next_shape", TTR("Next Coordinate"), KEY_PAGEDOWN));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_NEXT]->connect("pressed", this, "_on_tool_clicked", varray(SELECT_NEXT));
tools[SELECT_NEXT]->set_tooltip(TTR("Select the next shape, subtile, or Tile."));
tools[SELECT_PREVIOUS] = memnew(ToolButton);
tool_hb->add_child(tools[SELECT_PREVIOUS]);
tool_hb->move_child(tools[SELECT_PREVIOUS], WORKSPACE_CREATE_SINGLE);
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_PREVIOUS]->set_shortcut(ED_SHORTCUT("tileset_editor/previous_shape", TTR("Previous Coordinate"), KEY_PAGEUP));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_PREVIOUS]->set_tooltip(TTR("Select the previous shape, subtile, or Tile."));
tools[SELECT_PREVIOUS]->connect("pressed", this, "_on_tool_clicked", varray(SELECT_PREVIOUS));
VSeparator *separator_shape_selection = memnew(VSeparator);
tool_hb->add_child(separator_shape_selection);
tool_hb->move_child(separator_shape_selection, WORKSPACE_CREATE_SINGLE);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
main_vb->add_child(tool_hb);
main_vb->add_child(memnew(HSeparator));
tool_hb = memnew(HBoxContainer);
g = Ref<ButtonGroup>(memnew(ButtonGroup));
Makes more editor strings translatable * "Add" button text in Groups Editor * "Receiver Method" in Connect Signal Dialog * "Play Mode" in Animation State Machine Editor * "Mesh Library" button text in Mesh Library editor plugin * Compose Array node button texts in Visual Script * Various button texts in TileSet Editor * Various Run Script errors
2019-12-21 07:57:15 +01:00
String label[EDITMODE_MAX] = {
TTR("Region"),
TTR("Collision"),
TTR("Occlusion"),
TTR("Navigation"),
TTR("Bitmask"),
TTR("Priority"),
TTR("Icon"),
TTR("Z Index")
};
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < (int)EDITMODE_MAX; i++) {
tool_editmode[i] = memnew(Button);
tool_editmode[i]->set_text(label[i]);
tool_editmode[i]->set_toggle_mode(true);
tool_editmode[i]->set_button_group(g);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[i]->connect("pressed", this, "_on_edit_mode_changed", varray(i));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tool_hb->add_child(tool_editmode[i]);
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
add hotkeys to tileset editor
2019-04-13 07:45:57 +02:00
tool_editmode[EDITMODE_REGION]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_region", TTR("Region Mode"), KEY_1));
tool_editmode[EDITMODE_COLLISION]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_collision", TTR("Collision Mode"), KEY_2));
tool_editmode[EDITMODE_OCCLUSION]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_occlusion", TTR("Occlusion Mode"), KEY_3));
tool_editmode[EDITMODE_NAVIGATION]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_navigation", TTR("Navigation Mode"), KEY_4));
tool_editmode[EDITMODE_BITMASK]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_bitmask", TTR("Bitmask Mode"), KEY_5));
tool_editmode[EDITMODE_PRIORITY]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_priority", TTR("Priority Mode"), KEY_6));
tool_editmode[EDITMODE_ICON]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_icon", TTR("Icon Mode"), KEY_7));
tool_editmode[EDITMODE_Z_INDEX]->set_shortcut(ED_SHORTCUT("tileset_editor/editmode_z_index", TTR("Z Index Mode"), KEY_8));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(tool_hb);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode = memnew(HSeparator);
main_vb->add_child(separator_editmode);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar = memnew(HBoxContainer);
Ref<ButtonGroup> tg(memnew(ButtonGroup));
tools[TOOL_SELECT] = memnew(ToolButton);
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[TOOL_SELECT]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_toggle_mode(true);
tools[TOOL_SELECT]->set_button_group(tg);
tools[TOOL_SELECT]->set_pressed(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[TOOL_SELECT]->connect("pressed", this, "_on_tool_clicked", varray(TOOL_SELECT));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask = memnew(VSeparator);
toolbar->add_child(separator_bitmask);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_COPY] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_COPY]->set_tooltip(TTR("Copy bitmask."));
tools[BITMASK_COPY]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_COPY));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_COPY]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_PASTE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_PASTE]->set_tooltip(TTR("Paste bitmask."));
tools[BITMASK_PASTE]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_PASTE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_PASTE]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_CLEAR] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_CLEAR]->set_tooltip(TTR("Erase bitmask."));
tools[BITMASK_CLEAR]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_CLEAR));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_CLEAR]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE] = memnew(ToolButton);
toolbar->add_child(tools[SHAPE_NEW_RECTANGLE]);
tools[SHAPE_NEW_RECTANGLE]->set_toggle_mode(true);
tools[SHAPE_NEW_RECTANGLE]->set_button_group(tg);
tools[SHAPE_NEW_RECTANGLE]->set_tooltip(TTR("Create a new rectangle."));
Fix a random crash in the TileSet editor Occurred when selecting polygon collision mode, then drawing a single point, then selecting rectangle mode, and finally trying to select a rectangle. (cherry picked from commit 7850d0316f1100eb0f6b4229fb76784ea20a3e75)
2020-06-17 20:55:11 +02:00
tools[SHAPE_NEW_RECTANGLE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_NEW_RECTANGLE));
added shortcuts/hotkeys for tileset editor plugin collision buttons, with suggested changes. (cherry picked from commit cf582262c2a877664c7b123867bc60dd5e2de616)
2020-11-19 04:54:27 +01:00
tools[SHAPE_NEW_RECTANGLE]->set_shortcut(ED_SHORTCUT("tileset_editor/shape_new_rectangle", TTR("New Rectangle"), KEY_MASK_SHIFT | KEY_R));
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_NEW_POLYGON] = memnew(ToolButton);
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[SHAPE_NEW_POLYGON]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_NEW_POLYGON]->set_toggle_mode(true);
tools[SHAPE_NEW_POLYGON]->set_button_group(tg);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_NEW_POLYGON]->set_tooltip(TTR("Create a new polygon."));
Fix a random crash in the TileSet editor Occurred when selecting polygon collision mode, then drawing a single point, then selecting rectangle mode, and finally trying to select a rectangle. (cherry picked from commit 7850d0316f1100eb0f6b4229fb76784ea20a3e75)
2020-06-17 20:55:11 +02:00
tools[SHAPE_NEW_POLYGON]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_NEW_POLYGON));
added shortcuts/hotkeys for tileset editor plugin collision buttons, with suggested changes. (cherry picked from commit cf582262c2a877664c7b123867bc60dd5e2de616)
2020-11-19 04:54:27 +01:00
tools[SHAPE_NEW_POLYGON]->set_shortcut(ED_SHORTCUT("tileset_editor/shape_new_polygon", TTR("New Polygon"), KEY_MASK_SHIFT | KEY_P));
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
separator_shape_toggle = memnew(VSeparator);
toolbar->add_child(separator_shape_toggle);
tools[SHAPE_TOGGLE_TYPE] = memnew(ToolButton);
tools[SHAPE_TOGGLE_TYPE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_TOGGLE_TYPE));
toolbar->add_child(tools[SHAPE_TOGGLE_TYPE]);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete = memnew(VSeparator);
toolbar->add_child(separator_delete);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_DELETE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_DELETE));
added shortcuts/hotkeys for tileset editor plugin collision buttons, with suggested changes. (cherry picked from commit cf582262c2a877664c7b123867bc60dd5e2de616)
2020-11-19 04:54:27 +01:00
tools[SHAPE_DELETE]->set_shortcut(ED_SHORTCUT("tileset_editor/shape_delete", TTR("Delete Selected Shape"), KEY_MASK_SHIFT | KEY_BACKSPACE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[SHAPE_DELETE]);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority = memnew(SpinBox);
spin_priority->set_min(1);
spin_priority->set_max(255);
spin_priority->set_step(1);
spin_priority->set_custom_minimum_size(Size2(100, 0));
spin_priority->connect("value_changed", this, "_on_priority_changed");
spin_priority->hide();
toolbar->add_child(spin_priority);
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index = memnew(SpinBox);
spin_z_index->set_min(VS::CANVAS_ITEM_Z_MIN);
spin_z_index->set_max(VS::CANVAS_ITEM_Z_MAX);
spin_z_index->set_step(1);
spin_z_index->set_custom_minimum_size(Size2(100, 0));
spin_z_index->connect("value_changed", this, "_on_z_index_changed");
spin_z_index->hide();
toolbar->add_child(spin_z_index);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
separator_grid = memnew(VSeparator);
toolbar->add_child(separator_grid);
tools[SHAPE_KEEP_INSIDE_TILE] = memnew(ToolButton);
tools[SHAPE_KEEP_INSIDE_TILE]->set_toggle_mode(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_pressed(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_tooltip(TTR("Keep polygon inside region Rect."));
toolbar->add_child(tools[SHAPE_KEEP_INSIDE_TILE]);
tools[TOOL_GRID_SNAP] = memnew(ToolButton);
tools[TOOL_GRID_SNAP]->set_toggle_mode(true);
tools[TOOL_GRID_SNAP]->set_tooltip(TTR("Enable snap and show grid (configurable via the Inspector)."));
tools[TOOL_GRID_SNAP]->connect("toggled", this, "_on_grid_snap_toggled");
toolbar->add_child(tools[TOOL_GRID_SNAP]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Control *separator = memnew(Control);
separator->set_h_size_flags(SIZE_EXPAND_FILL);
toolbar->add_child(separator);
tools[ZOOM_OUT] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_OUT]->connect("pressed", this, "_zoom_out");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_OUT]);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[ZOOM_OUT]->set_tooltip(TTR("Zoom Out"));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[ZOOM_1] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_1]->connect("pressed", this, "_zoom_reset");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_1]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_1]->set_tooltip(TTR("Zoom Reset"));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[ZOOM_IN] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_IN]->connect("pressed", this, "_zoom_in");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_IN]);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[ZOOM_IN]->set_tooltip(TTR("Zoom In"));
tools[VISIBLE_INFO] = memnew(ToolButton);
tools[VISIBLE_INFO]->set_toggle_mode(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[VISIBLE_INFO]->set_tooltip(TTR("Display Tile Names (Hold Alt Key)"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[VISIBLE_INFO]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(toolbar);
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
scroll = memnew(ScrollContainer);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(scroll);
scroll->set_v_size_flags(SIZE_EXPAND_FILL);
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
scroll->connect("gui_input", this, "_on_scroll_container_input");
New TileSet Editor
2018-07-29 23:54:12 +02:00
scroll->set_clip_contents(true);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Add informational messages to various editors
2019-09-04 07:20:57 +02:00
empty_message = memnew(Label);
empty_message->set_text(TTR("Add or select a texture on the left panel to edit the tiles bound to it."));
empty_message->set_valign(Label::VALIGN_CENTER);
empty_message->set_align(Label::ALIGN_CENTER);
empty_message->set_autowrap(true);
Fixed cases where labels with autowrap can overflow the editor ui Fixes #33155
2019-11-04 10:12:15 +01:00
empty_message->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
Add informational messages to various editors
2019-09-04 07:20:57 +02:00
empty_message->set_v_size_flags(SIZE_EXPAND_FILL);
main_vb->add_child(empty_message);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace_container = memnew(Control);
scroll->add_child(workspace_container);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace_overlay = memnew(Control);
workspace_overlay->connect("draw", this, "_on_workspace_overlay_draw");
workspace_container->add_child(workspace_overlay);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace = memnew(Control);
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->set_focus_mode(FOCUS_ALL);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->connect("draw", this, "_on_workspace_draw");
workspace->connect("gui_input", this, "_on_workspace_input");
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace->set_draw_behind_parent(true);
workspace_overlay->add_child(workspace);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
preview = memnew(Sprite);
workspace->add_child(preview);
preview->set_centered(false);
preview->set_draw_behind_parent(true);
New TileSet Editor
2018-07-29 23:54:12 +02:00
preview->set_position(WORKSPACE_MARGIN);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
cd = memnew(ConfirmationDialog);
add_child(cd);
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->connect("confirmed", this, "_on_tileset_toolbar_confirm");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
err_dialog = memnew(AcceptDialog);
add_child(err_dialog);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
texture_dialog = memnew(EditorFileDialog);
texture_dialog->set_access(EditorFileDialog::ACCESS_RESOURCES);
texture_dialog->set_mode(EditorFileDialog::MODE_OPEN_FILES);
texture_dialog->clear_filters();
List<String> extensions;
ResourceLoader::get_recognized_extensions_for_type("Texture", &extensions);
for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
texture_dialog->add_filter("*." + E->get() + " ; " + E->get().to_upper());
}
add_child(texture_dialog);
texture_dialog->connect("files_selected", this, "_on_textures_added");
//---------------
helper = memnew(TilesetEditorContext(this));
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
tile_names_visible = false;
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
Add informational messages to various editors
2019-09-04 07:20:57 +02:00
// Config scale.
Increase the TileSet and polygon UV editor zoom limits to 16× This also changes the TileSet editor's minimum zoom to match other 2D editors. This closes #34346.
2019-12-14 20:48:47 +01:00
max_scale = 16.0f;
min_scale = 0.01f;
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
scale_ratio = 1.2f;
fix updating tileset list when assign texture and set autotile true
2018-01-10 23:45:14 +01:00
}
TileSetEditorPlgn: Fix a leak
2018-02-27 03:54:09 +01:00
TileSetEditor::~TileSetEditor() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (helper) {
TileSetEditorPlgn: Fix a leak
2018-02-27 03:54:09 +01:00
memdelete(helper);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
TileSetEditorPlgn: Fix a leak
2018-02-27 03:54:09 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_tileset_toolbar_button_pressed(int p_index) {
option = p_index;
switch (option) {
case TOOL_TILESET_ADD_TEXTURE: {
texture_dialog->popup_centered_ratio();
} break;
case TOOL_TILESET_REMOVE_TEXTURE: {
if (get_current_texture().is_valid()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
cd->set_text(TTR("Remove selected texture? This will remove all tiles which use it."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->popup_centered(Size2(300, 60));
} else {
err_dialog->set_text(TTR("You haven't selected a texture to remove."));
err_dialog->popup_centered(Size2(300, 60));
}
} break;
case TOOL_TILESET_CREATE_SCENE: {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
cd->set_text(TTR("Create from scene? This will overwrite all current tiles."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->popup_centered(Size2(300, 60));
} break;
case TOOL_TILESET_MERGE_SCENE: {
cd->set_text(TTR("Merge from scene?"));
cd->popup_centered(Size2(300, 60));
} break;
}
}
void TileSetEditor::_on_tileset_toolbar_confirm() {
switch (option) {
case TOOL_TILESET_REMOVE_TEXTURE: {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String current_texture_path = get_current_texture()->get_path();
New TileSet Editor
2018-07-29 23:54:12 +02:00
List<int> ids;
tileset->get_tile_list(&ids);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Remove Texture"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
if (tileset->tile_get_texture(E->get())->get_path() == current_texture_path) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "remove_tile", E->get());
_undo_tile_removal(E->get());
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "remove_texture", get_current_texture());
undo_redo->add_undo_method(this, "add_texture", get_current_texture());
undo_redo->add_undo_method(this, "update_texture_list_icon");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
case TOOL_TILESET_MERGE_SCENE:
case TOOL_TILESET_CREATE_SCENE: {
EditorNode *en = editor;
Node *scene = en->get_edited_scene();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!scene) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
List<int> ids;
tileset->get_tile_list(&ids);
undo_redo->create_action(TTR(option == TOOL_TILESET_MERGE_SCENE ? "Merge Tileset from Scene" : "Create Tileset from Scene"));
undo_redo->add_do_method(this, "_undo_redo_import_scene", scene, option == TOOL_TILESET_MERGE_SCENE);
undo_redo->add_undo_method(tileset.ptr(), "clear");
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
_undo_tile_removal(E->get());
}
undo_redo->add_do_method(this, "edit", tileset);
undo_redo->add_undo_method(this, "edit", tileset);
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
}
}
void TileSetEditor::_on_texture_list_selected(int p_index) {
if (get_current_texture().is_valid()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
current_item_index = p_index;
New TileSet Editor
2018-07-29 23:54:12 +02:00
preview->set_texture(get_current_texture());
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
update_workspace_tile_mode();
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
update_workspace_minsize();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
current_item_index = -1;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 16:00:45 +02:00
preview->set_texture(nullptr);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->set_custom_minimum_size(Size2i());
New TileSet Editor
2018-07-29 23:54:12 +02:00
update_workspace_tile_mode();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
set_current_tile(-1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_textures_added(const PoolStringArray &p_paths) {
int invalid_count = 0;
for (int i = 0; i < p_paths.size(); i++) {
Ref<Texture> t = Ref<Texture>(ResourceLoader::load(p_paths[i]));
TileSetEditor: Don't crash when adding invalid files
2018-10-11 17:13:44 +02:00
Replace 'ERR_EXPLAIN' with 'ERR_FAIL_*_MSG' in 'core/' and 'editor/' Condensed some if and ERR statements. Added dots to end of error messages Couldn't figure out EXPLAINC. These files gave me trouble: core/error_macros.h, core/io/file_access_buffered_fa.h (where is it?), core/os/memory.cpp, drivers/png/png_driver_common.cpp, drivers/xaudio2/audio_driver_xaudio2.cpp (where is it?)
2019-08-15 04:57:49 +02:00
ERR_CONTINUE_MSG(!t.is_valid(), "'" + p_paths[i] + "' is not a valid texture.");
TileSetEditor: Don't crash when adding invalid files
2018-10-11 17:13:44 +02:00
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
if (texture_map.has(t->get_path())) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
invalid_count++;
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
add_texture(t);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
TileSetEditor: Don't crash when adding invalid files
2018-10-11 17:13:44 +02:00
if (texture_list->get_item_count() > 0) {
update_texture_list_icon();
texture_list->select(texture_list->get_item_count() - 1);
_on_texture_list_selected(texture_list->get_item_count() - 1);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (invalid_count > 0) {
Fix vformat(), minor typos and word puzzles
2018-08-28 20:15:04 +02:00
err_dialog->set_text(vformat(TTR("%s file(s) were not added because was already on the list."), String::num(invalid_count, 0)));
New TileSet Editor
2018-07-29 23:54:12 +02:00
err_dialog->popup_centered(Size2(300, 60));
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_edit_mode_changed(int p_edit_mode) {
Fixes editor crashing when editing autotiles issue #24004
2018-12-06 10:35:38 +01:00
draw_handles = false;
creating_shape = false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
edit_mode = (EditMode)p_edit_mode;
switch (edit_mode) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
case EDITMODE_REGION: {
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
if (workspace_mode == WORKSPACE_EDIT) {
separator_delete->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
} else {
separator_delete->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
}
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_GRID_SNAP]->show();
tools[TOOL_SELECT]->set_pressed(true);
tools[TOOL_SELECT]->set_tooltip(TTR("Drag handles to edit Rect.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete selected Rect."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_COLLISION:
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->show();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->show();
tools[TOOL_GRID_SNAP]->show();
tools[TOOL_SELECT]->set_tooltip(TTR("Select current edited sub-tile.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete polygon."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
case EDITMODE_BITMASK: {
tools[TOOL_SELECT]->show();
separator_bitmask->show();
tools[BITMASK_COPY]->show();
tools[BITMASK_PASTE]->show();
tools[BITMASK_CLEAR]->show();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_delete->hide();
tools[SHAPE_DELETE]->hide();
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_SELECT]->set_pressed(true);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("LMB: Set bit on.\nRMB: Set bit off.\nShift+LMB: Set wildcard bit.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
spin_priority->hide();
} break;
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_Z_INDEX:
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
case EDITMODE_PRIORITY:
case EDITMODE_ICON: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_GRID_SNAP]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (edit_mode == EDITMODE_ICON) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to use as icon, this will be also used on invalid autotile bindings.\nClick on another Tile to edit it."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
} else if (edit_mode == EDITMODE_PRIORITY) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to change its priority.\nClick on another Tile to edit it."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->show();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
} else {
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to change its z index.\nClick on another Tile to edit it."));
spin_priority->hide();
spin_z_index->show();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_update_toggle_shape_button();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_workspace_mode_changed(int p_workspace_mode) {
workspace_mode = (WorkspaceMode)p_workspace_mode;
if (p_workspace_mode == WORKSPACE_EDIT) {
update_workspace_tile_mode();
} else {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
tool_editmode[EDITMODE_REGION]->show();
tool_editmode[EDITMODE_REGION]->set_pressed(true);
_on_edit_mode_changed(EDITMODE_REGION);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_workspace_draw() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset.is_null() || !get_current_texture().is_valid()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
const Color COLOR_AUTOTILE = Color(0.3, 0.6, 1);
const Color COLOR_SINGLE = Color(1, 1, 0.3);
const Color COLOR_ATLAS = Color(0.8, 0.8, 0.8);
const Color COLOR_SUBDIVISION = Color(0.3, 0.7, 0.6);
draw_handles = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_current_tile();
draw_grid_snap();
if (get_current_tile() >= 0) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Rect2i region = tileset->tile_get_region(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
switch (edit_mode) {
case EDITMODE_ICON: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = tileset->autotile_get_icon_coordinate(get_current_tile());
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_subtile(coord);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_BITMASK: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Color c(1, 0, 0, 0.5);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
Color ci(0.3, 0.6, 1, 0.5);
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02:00
for (int x = 0; x < region.size.x / (spacing + size.x); x++) {
for (int y = 0; y < region.size.y / (spacing + size.y); y++) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 coord(x, y);
Point2 anchor(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += region.position;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 4), ci);
workspace->draw_rect(Rect2(anchor + size / 4, size / 4), ci);
} else if (mask & TileSet::BIND_TOPLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor, size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPRIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, 0), size / 4), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 3 / 4, size.y / 4), size / 4), ci);
} else if (mask & TileSet::BIND_TOPRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, 0), size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMLEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 2), size / 4), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 4, size.y * 3 / 4), size / 4), ci);
} else if (mask & TileSet::BIND_BOTTOMLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 2), size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMRIGHT) {
workspace->draw_rect(Rect2(anchor + size / 2, size / 4), ci);
workspace->draw_rect(Rect2(anchor + size * 3 / 4, size / 4), ci);
} else if (mask & TileSet::BIND_BOTTOMRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + size / 2, size / 2), c);
}
Restore support for minimal 3x3 autotile sets
2018-05-17 05:39:43 +02:00
} else {
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size / 6, size / 6), ci);
} else if (mask & TileSet::BIND_TOPLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor, size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOP) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, 0), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, size.y / 6), size / 6), ci);
} else if (mask & TileSet::BIND_TOP) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, 0), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPRIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 4 / 6, 0), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 5 / 6, size.y / 6), size / 6), ci);
} else if (mask & TileSet::BIND_TOPRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, 0), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_LEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 3), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 6, size.y / 2), size / 6), ci);
} else if (mask & TileSet::BIND_LEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_CENTER) {
workspace->draw_rect(Rect2(anchor + size / 3, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size / 2, size / 6), ci);
} else if (mask & TileSet::BIND_CENTER) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_RIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 4 / 6, size.y / 3), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 5 / 6, size.y / 2), size / 6), ci);
} else if (mask & TileSet::BIND_RIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMLEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y * 4 / 6), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 6, size.y * 5 / 6), size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOMLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, (size.y / 3) * 2), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOM) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, size.y * 4 / 6), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, size.y * 5 / 6), size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOM) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, (size.y / 3) * 2), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMRIGHT) {
workspace->draw_rect(Rect2(anchor + size * 4 / 6, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size * 5 / 6, size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOMRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + (size / 3) * 2, size / 3), c);
}
}
}
}
} break;
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 10:11:05 +02:00
draw_highlight_subtile(edited_shape_coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
draw_polygon_shapes();
Autotile Enhancement
2017-12-28 06:57:37 +01:00
draw_grid_snap();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_PRIORITY: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
spin_priority->set_value(tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), edited_shape_coord);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> queue_others;
int total = 0;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (E->value() == mask) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
total += tileset->autotile_get_subtile_priority(get_current_tile(), E->key());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (E->key() != edited_shape_coord) {
queue_others.push_back(E->key());
}
}
}
spin_priority->set_suffix(" / " + String::num(total, 0));
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_subtile(edited_shape_coord, queue_others);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_Z_INDEX: {
spin_z_index->set_value(tileset->autotile_get_z_index(get_current_tile(), edited_shape_coord));
draw_highlight_subtile(edited_shape_coord);
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String current_texture_path = get_current_texture()->get_path();
List<int> tiles;
tileset->get_tile_list(&tiles);
for (List<int>::Element *E = tiles.front(); E; E = E->next()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
int t_id = E->get();
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
if (tileset->tile_get_texture(t_id)->get_path() == current_texture_path && (t_id != get_current_tile() || edit_mode != EDITMODE_REGION || workspace_mode != WORKSPACE_EDIT)) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2i region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
Color c;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_SINGLE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_AUTOTILE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_ATLAS;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(region, c, false);
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (edit_mode == EDITMODE_REGION) {
if (workspace_mode != WORKSPACE_EDIT) {
Rect2i region = edited_region;
Color c;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (workspace_mode == WORKSPACE_CREATE_SINGLE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_SINGLE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (workspace_mode == WORKSPACE_CREATE_AUTOTILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_AUTOTILE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (workspace_mode == WORKSPACE_CREATE_ATLAS) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_ATLAS;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(region, c, false);
draw_edited_region_subdivision();
} else {
int t_id = get_current_tile();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (t_id < 0) {
Fix small drawing error in TileSet editor
2018-12-20 22:52:56 +01:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Fix small drawing error in TileSet editor
2018-12-20 22:52:56 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2i region;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (draw_edited_region) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
region = edited_region;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
New TileSet Editor
2018-07-29 23:54:12 +02:00
region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (draw_edited_region) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
draw_edited_region_subdivision();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Color c;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_SINGLE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_AUTOTILE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
c = COLOR_ATLAS;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(region, c, false);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace_overlay->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_workspace_process() {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
if (Input::get_singleton()->is_key_pressed(KEY_ALT) || tools[VISIBLE_INFO]->is_pressed()) {
if (!tile_names_visible) {
tile_names_visible = true;
workspace_overlay->update();
}
} else if (tile_names_visible) {
tile_names_visible = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace_overlay->update();
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
void TileSetEditor::_on_workspace_overlay_draw() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!tileset.is_valid() || !get_current_texture().is_valid()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
const Color COLOR_AUTOTILE = Color(0.266373, 0.565288, 0.988281);
const Color COLOR_SINGLE = Color(0.988281, 0.909323, 0.266373);
const Color COLOR_ATLAS = Color(0.78653, 0.812835, 0.832031);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
if (tile_names_visible) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String current_texture_path = get_current_texture()->get_path();
List<int> tiles;
tileset->get_tile_list(&tiles);
for (List<int>::Element *E = tiles.front(); E; E = E->next()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
int t_id = E->get();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset->tile_get_texture(t_id)->get_path() != current_texture_path) {
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
Rect2 region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
region.position *= workspace->get_scale().x;
Color c;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE) {
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
c = COLOR_SINGLE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE) {
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
c = COLOR_AUTOTILE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE) {
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
c = COLOR_ATLAS;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-12 00:01:18 +02:00
String tile_id_name = String::num(t_id, 0) + ": " + tileset->tile_get_name(t_id);
Ref<Font> font = get_font("font", "Label");
region.set_size(font->get_string_size(tile_id_name));
workspace_overlay->draw_rect(region, c);
region.position.y += region.size.y - 2;
c = Color(0.1, 0.1, 0.1);
workspace_overlay->draw_string(font, region.position, tile_id_name, c);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
int t_id = get_current_tile();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (t_id < 0) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (draw_handles) {
for (int i = 0; i < current_shape.size(); i++) {
workspace_overlay->draw_texture(handle, current_shape[i] * workspace->get_scale().x - handle->get_size() * 0.5);
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
int TileSetEditor::get_grabbed_point(const Vector2 &p_mouse_pos, real_t p_grab_threshold) {
Transform2D xform = workspace->get_transform();
int grabbed_point = -1;
real_t min_distance = 1e10;
for (int i = 0; i < current_shape.size(); i++) {
const real_t distance = xform.xform(current_shape[i]).distance_to(xform.xform(p_mouse_pos));
if (distance < p_grab_threshold && distance < min_distance) {
min_distance = distance;
grabbed_point = i;
}
}
return grabbed_point;
}
bool TileSetEditor::is_within_grabbing_distance_of_first_point(const Vector2 &p_pos, real_t p_grab_threshold) {
Transform2D xform = workspace->get_transform();
const real_t distance = xform.xform(current_shape[0]).distance_to(xform.xform(p_pos));
return distance < p_grab_threshold;
}
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
void TileSetEditor::_on_scroll_container_input(const Ref<InputEvent> &p_event) {
const Ref<InputEventMouseButton> mb = p_event;
if (mb.is_valid()) {
// Zoom in/out using Ctrl + mouse wheel. This is done on the ScrollContainer
// to allow performing this action anywhere, even if the cursor isn't
// hovering the texture in the workspace.
if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed() && mb->get_control()) {
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
_zoom_on_position(scale_ratio, mb->get_position());
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
// Don't scroll up after zooming in.
accept_event();
} else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed() && mb->get_control()) {
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
_zoom_on_position(1 / scale_ratio, mb->get_position());
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
// Don't scroll down after zooming out.
accept_event();
}
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset.is_null() || !get_current_texture().is_valid()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
static bool dragging;
static bool erasing;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
static bool alternative;
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_edited_region = false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 current_tile_region = Rect2();
if (get_current_tile() >= 0) {
current_tile_region = tileset->tile_get_region(get_current_tile());
}
current_tile_region.position += WORKSPACE_MARGIN;
Allow mouse zooming without hovering the texture in the TileSet editor This partially addresses https://github.com/godotengine/godot-proposals/issues/968. (cherry picked from commit d10a5b2928175b313baf709b480620d755983f36)
2020-05-30 12:29:53 +02:00
const Ref<InputEventMouseButton> mb = p_ie;
const Ref<InputEventMouseMotion> mm = p_ie;
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (mb.is_valid()) {
fix tile set editor crash when drawing polygon shapes
2018-11-07 19:10:13 +01:00
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && !creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (!current_tile_region.has_point(mb->get_position())) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String current_texture_path = get_current_texture()->get_path();
List<int> tiles;
tileset->get_tile_list(&tiles);
for (List<int>::Element *E = tiles.front(); E; E = E->next()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
int t_id = E->get();
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
if (tileset->tile_get_texture(t_id)->get_path() == current_texture_path) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 r = tileset->tile_get_region(t_id);
r.position += WORKSPACE_MARGIN;
if (r.has_point(mb->get_position())) {
set_current_tile(t_id);
workspace->update();
workspace_overlay->update();
return;
}
}
}
}
}
}
// Drag Middle Mouse
if (mm.is_valid()) {
if (mm->get_button_mask() & BUTTON_MASK_MIDDLE) {
Vector2 dragged(mm->get_relative().x, mm->get_relative().y);
scroll->set_h_scroll(scroll->get_h_scroll() - dragged.x * workspace->get_scale().x);
scroll->set_v_scroll(scroll->get_v_scroll() - dragged.y * workspace->get_scale().x);
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (edit_mode == EDITMODE_REGION) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (get_current_tile() >= 0 || workspace_mode != WORKSPACE_EDIT) {
dragging = true;
region_from = mb->get_position();
edited_region = Rect2(region_from, Size2());
workspace->update();
workspace_overlay->update();
return;
}
} else if (dragging && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
dragging = false;
edited_region = Rect2();
workspace->update();
workspace_overlay->update();
return;
} else if (dragging && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
dragging = false;
update_edited_region(mb->get_position());
edited_region.position -= WORKSPACE_MARGIN;
if (!edited_region.has_no_area()) {
if (get_current_tile() >= 0 && workspace_mode == WORKSPACE_EDIT) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Set Tile Region"));
undo_redo->add_do_method(tileset.ptr(), "tile_set_region", get_current_tile(), edited_region);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_region", get_current_tile(), tileset->tile_get_region(get_current_tile()));
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Size2 tile_workspace_size = edited_region.position + edited_region.size + WORKSPACE_MARGIN * 2;
Size2 workspace_minsize = workspace->get_custom_minimum_size();
Fix TileSet editor's workspace size sometimes not changing correctly on region change
2020-01-10 04:57:49 +01:00
// If the new region is bigger, just directly change the workspace size to avoid checking all other tiles.
if (tile_workspace_size.x > workspace_minsize.x || tile_workspace_size.y > workspace_minsize.y) {
Size2 max_workspace_size = Size2(MAX(tile_workspace_size.x, workspace_minsize.x), MAX(tile_workspace_size.y, workspace_minsize.y));
undo_redo->add_do_method(workspace, "set_custom_minimum_size", max_workspace_size);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
undo_redo->add_undo_method(workspace, "set_custom_minimum_size", workspace_minsize);
Fix TileSet editor's workspace size sometimes not changing correctly on region change
2020-01-10 04:57:49 +01:00
undo_redo->add_do_method(workspace_container, "set_custom_minimum_size", max_workspace_size);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
undo_redo->add_undo_method(workspace_container, "set_custom_minimum_size", workspace_minsize);
Fix TileSet editor's workspace size sometimes not changing correctly on region change
2020-01-10 04:57:49 +01:00
undo_redo->add_do_method(workspace_overlay, "set_custom_minimum_size", max_workspace_size);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
undo_redo->add_undo_method(workspace_overlay, "set_custom_minimum_size", workspace_minsize);
} else if (workspace_minsize.x > get_current_texture()->get_size().x + WORKSPACE_MARGIN.x * 2 || workspace_minsize.y > get_current_texture()->get_size().y + WORKSPACE_MARGIN.y * 2) {
undo_redo->add_do_method(this, "update_workspace_minsize");
undo_redo->add_undo_method(this, "update_workspace_minsize");
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_region = Rect2();
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
int t_id = tileset->get_last_unused_tile_id();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Tile"));
undo_redo->add_do_method(tileset.ptr(), "create_tile", t_id);
undo_redo->add_undo_method(tileset.ptr(), "remove_tile", t_id);
undo_redo->add_undo_method(this, "_validate_current_tile_id");
undo_redo->add_do_method(tileset.ptr(), "tile_set_texture", t_id, get_current_texture());
undo_redo->add_do_method(tileset.ptr(), "tile_set_region", t_id, edited_region);
undo_redo->add_do_method(tileset.ptr(), "tile_set_name", t_id, get_current_texture()->get_path().get_file() + " " + String::num(t_id, 0));
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode != WORKSPACE_CREATE_SINGLE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "autotile_set_size", t_id, snap_step);
undo_redo->add_do_method(tileset.ptr(), "autotile_set_spacing", t_id, snap_separation.x);
undo_redo->add_do_method(tileset.ptr(), "tile_set_tile_mode", t_id, workspace_mode == WORKSPACE_CREATE_AUTOTILE ? TileSet::AUTO_TILE : TileSet::ATLAS_TILE);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Size2 tile_workspace_size = edited_region.position + edited_region.size + WORKSPACE_MARGIN * 2;
Size2 workspace_minsize = workspace->get_custom_minimum_size();
if (tile_workspace_size.x > workspace_minsize.x || tile_workspace_size.y > workspace_minsize.y) {
Size2 new_workspace_minsize = Size2(MAX(tile_workspace_size.x, workspace_minsize.x), MAX(tile_workspace_size.y, workspace_minsize.y));
undo_redo->add_do_method(workspace, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_container, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace_container, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_overlay, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace_overlay, "set_custom_minimum_size", workspace_minsize);
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_region = Rect2();
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
set_current_tile(t_id);
New TileSet Editor
2018-07-29 23:54:12 +02:00
_on_workspace_mode_changed(WORKSPACE_EDIT);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
} else {
edited_region = Rect2();
workspace->update();
workspace_overlay->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
}
} else if (mm.is_valid()) {
if (dragging) {
update_edited_region(mm->get_position());
draw_edited_region = true;
workspace->update();
workspace_overlay->update();
return;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (workspace_mode == WORKSPACE_EDIT) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (get_current_tile() >= 0) {
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
switch (edit_mode) {
case EDITMODE_ICON: {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && current_tile_region.has_point(mb->get_position())) {
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Set Tile Icon"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_icon_coordinate", get_current_tile(), coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_icon_coordinate", get_current_tile(), tileset->autotile_get_icon_coordinate(get_current_tile()));
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} break;
case EDITMODE_BITMASK: {
if (mb.is_valid()) {
if (mb->is_pressed()) {
if (dragging) {
return;
}
if ((mb->get_button_index() == BUTTON_RIGHT || mb->get_button_index() == BUTTON_LEFT) && current_tile_region.has_point(mb->get_position())) {
dragging = true;
erasing = (mb->get_button_index() == BUTTON_RIGHT);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
alternative = Input::get_singleton()->is_key_pressed(KEY_SHIFT);
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
pos = mb->get_position() - (pos + current_tile_region.position);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t bit = 0;
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
} else {
bit = TileSet::BIND_BOTTOMLEFT;
}
} else {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPRIGHT;
} else {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
} else {
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMLEFT;
} else {
bit = TileSet::BIND_LEFT;
}
} else if (pos.x > (size.x / 3) * 2) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPRIGHT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMRIGHT;
} else {
bit = TileSet::BIND_RIGHT;
}
} else {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOP;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOM;
} else {
bit = TileSet::BIND_CENTER;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t old_mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
uint32_t new_mask = old_mask;
if (alternative) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask &= ~bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask |= (bit << 16);
} else if (erasing) {
new_mask &= ~bit;
new_mask &= ~(bit << 16);
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask |= bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (old_mask != new_mask) {
undo_redo->create_action(TTR("Edit Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, new_mask);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, old_mask);
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} else {
if ((erasing && mb->get_button_index() == BUTTON_RIGHT) || (!erasing && mb->get_button_index() == BUTTON_LEFT)) {
dragging = false;
erasing = false;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
alternative = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (mm.is_valid()) {
if (dragging && current_tile_region.has_point(mm->get_position())) {
Vector2 coord((int)((mm->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mm->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 23:54:12 +02:00
pos = mm->get_position() - (pos + current_tile_region.position);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t bit = 0;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
} else {
bit = TileSet::BIND_BOTTOMLEFT;
}
} else {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPRIGHT;
} else {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
Restore support for minimal 3x3 autotile sets
2018-05-17 05:39:43 +02:00
} else {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMLEFT;
} else {
bit = TileSet::BIND_LEFT;
}
} else if (pos.x > (size.x / 3) * 2) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPRIGHT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMRIGHT;
} else {
bit = TileSet::BIND_RIGHT;
}
} else {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOP;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOM;
} else {
bit = TileSet::BIND_CENTER;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t old_mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
uint32_t new_mask = old_mask;
if (alternative) {
new_mask &= ~bit;
new_mask |= (bit << 16);
} else if (erasing) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask &= ~bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask |= bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
if (old_mask != new_mask) {
undo_redo->create_action(TTR("Edit Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, new_mask);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, old_mask);
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector2 shape_anchor = Vector2(0, 0);
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
const real_t grab_threshold = EDITOR_GET("editors/poly_editor/point_grab_radius");
New TileSet Editor
2018-07-29 23:54:12 +02:00
shape_anchor += current_tile_region.position;
if (tools[TOOL_SELECT]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (edit_mode != EDITMODE_PRIORITY && current_shape.size() > 0) {
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
int grabbed_point = get_grabbed_point(mb->get_position(), grab_threshold);
if (grabbed_point >= 0) {
dragging_point = grabbed_point;
workspace->update();
return;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if ((tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) && current_tile_region.has_point(mb->get_position())) {
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
if (edited_shape_coord != coord) {
edited_shape_coord = coord;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
} else if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (edit_mode == EDITMODE_COLLISION) {
if (dragging_point >= 0) {
dragging_point = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector<Vector2> points;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (int i = 0; i < current_shape.size(); i++) {
Vector2 p = current_shape[i];
if (tools[TOOL_GRID_SNAP]->is_pressed() || tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
p = snap_point(p);
}
points.push_back(p - shape_anchor);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Collision Polygon"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_shape_points(points);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
if (dragging_point >= 0) {
dragging_point = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
PoolVector<Vector2> polygon;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Added release function to PoolVector::Access. For clarity, assign-to-release idiom for PoolVector::Read/Write replaced with a function call. Existing uses replaced (or removed if already handled by scope)
2019-07-05 19:08:43 +02:00
w.release();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Occlusion Polygon"));
undo_redo->add_do_method(edited_occlusion_shape.ptr(), "set_polygon", polygon);
undo_redo->add_undo_method(edited_occlusion_shape.ptr(), "set_polygon", edited_occlusion_shape->get_polygon());
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (edit_mode == EDITMODE_NAVIGATION) {
if (dragging_point >= 0) {
dragging_point = -1;
PoolVector<Vector2> polygon;
Vector<int> indices;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
indices.push_back(i);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Added release function to PoolVector::Access. For clarity, assign-to-release idiom for PoolVector::Read/Write replaced with a function call. Existing uses replaced (or removed if already handled by scope)
2019-07-05 19:08:43 +02:00
w.release();
fix crash autotile edit mode
2018-02-16 11:48:01 +01:00
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
edited_navigation_shape->clear_outlines();
edited_navigation_shape->add_outline(polygon);
edited_navigation_shape->make_polygons_from_outlines();
// FIXME Couldn't figure out the undo_redo quagmire
//undo_redo->create_action(TTR("Edit Navigation Polygon"));
//undo_redo->add_do_method(edited_navigation_shape.ptr(), "set_vertices", polygon);
//undo_redo->add_undo_method(edited_navigation_shape.ptr(), "set_vertices", edited_navigation_shape->get_vertices());
//undo_redo->add_do_method(edited_navigation_shape.ptr(), "clear_polygons");
//undo_redo->add_undo_method(edited_navigation_shape.ptr(), "clear_polygons");
//undo_redo->add_do_method(edited_navigation_shape.ptr(), "add_polygon", indices);
//undo_redo->add_undo_method(edited_navigation_shape.ptr(), "add_polygon", edited_navigation_shape->get_polygon(0));
//undo_redo->add_do_method(this, "_select_edited_shape_coord");
//undo_redo->add_undo_method(this, "_select_edited_shape_coord");
//undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
} else if (mm.is_valid()) {
if (dragging_point >= 0) {
current_shape.set(dragging_point, snap_point(mm->get_position()));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} else if (tools[SHAPE_NEW_POLYGON]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
Vector2 pos = mb->get_position();
pos = snap_point(pos);
if (creating_shape) {
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
if (current_shape.size() > 2) {
if (is_within_grabbing_distance_of_first_point(mb->get_position(), grab_threshold)) {
close_shape(shape_anchor);
workspace->update();
return;
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
current_shape.push_back(pos);
workspace->update();
} else {
creating_shape = true;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>());
New TileSet Editor
2018-07-29 23:54:12 +02:00
current_shape.resize(0);
current_shape.push_back(snap_point(pos));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
} else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (creating_shape) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
creating_shape = false;
_select_edited_shape_coord();
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (mm.is_valid()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
} else if (tools[SHAPE_NEW_RECTANGLE]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>());
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
current_shape.resize(0);
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 22:35:00 +02:00
Vector2 pos = mb->get_position();
pos = snap_point(pos);
current_shape.push_back(pos);
current_shape.push_back(pos);
current_shape.push_back(pos);
current_shape.push_back(pos);
creating_shape = true;
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
workspace->update();
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 22:35:00 +02:00
return;
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
} else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 22:35:00 +02:00
if (creating_shape) {
creating_shape = false;
_select_edited_shape_coord();
workspace->update();
}
} else if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (creating_shape) {
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
// if the first two corners are within grabbing distance of one another, expand the rect to fill the tile
if (is_within_grabbing_distance_of_first_point(current_shape[1], grab_threshold)) {
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 22:35:00 +02:00
current_shape.set(0, snap_point(shape_anchor));
current_shape.set(1, snap_point(shape_anchor + Vector2(current_tile_region.size.x, 0)));
current_shape.set(2, snap_point(shape_anchor + current_tile_region.size));
current_shape.set(3, snap_point(shape_anchor + Vector2(0, current_tile_region.size.y)));
}
Fixed another point grabbing issue at lower zoom levels. This was caused by the fact that the points were being iterated sequentially and we were breaking out of the loop as soon as we found a point that was "close enough", rather than actually finding the closest point. The previous fix exposed this new issue.
2019-12-01 21:35:23 +01:00
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 22:35:00 +02:00
close_shape(shape_anchor);
workspace->update();
return;
}
}
} else if (mm.is_valid()) {
if (creating_shape) {
Vector2 pos = mm->get_position();
pos = snap_point(pos);
Vector2 p = current_shape[2];
current_shape.set(3, snap_point(Vector2(pos.x, p.y)));
current_shape.set(0, snap_point(pos));
current_shape.set(1, snap_point(Vector2(p.x, pos.y)));
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
workspace->update();
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_tool_clicked(int p_tool) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (p_tool == BITMASK_COPY) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
bitmask_map_copy = tileset->autotile_get_bitmask_map(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == BITMASK_PASTE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Paste Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
undo_redo->add_undo_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = bitmask_map_copy.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
}
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == BITMASK_CLEAR) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Clear Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
}
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
} else if (p_tool == SHAPE_TOGGLE_TYPE) {
if (edited_collision_shape.is_valid()) {
Ref<ConvexPolygonShape2D> convex = edited_collision_shape;
Ref<ConcavePolygonShape2D> concave = edited_collision_shape;
Ref<Shape2D> previous_shape = edited_collision_shape;
Array sd = tileset->call("tile_get_shapes", get_current_tile());
if (convex.is_valid()) {
Fix problems with concave shapes in the TileSet editor (cherry picked from commit eeb972faefc988833693faea77d81cc8d2d2d2b4)
2020-02-11 22:31:25 +01:00
// Make concave.
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
undo_redo->create_action(TTR("Make Polygon Concave"));
Ref<ConcavePolygonShape2D> _concave = memnew(ConcavePolygonShape2D);
edited_collision_shape = _concave;
_set_edited_shape_points(_get_collision_shape_points(convex));
} else if (concave.is_valid()) {
Fix problems with concave shapes in the TileSet editor (cherry picked from commit eeb972faefc988833693faea77d81cc8d2d2d2b4)
2020-02-11 22:31:25 +01:00
// Make convex.
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
undo_redo->create_action(TTR("Make Polygon Convex"));
Ref<ConvexPolygonShape2D> _convex = memnew(ConvexPolygonShape2D);
edited_collision_shape = _convex;
_set_edited_shape_points(_get_collision_shape_points(concave));
}
for (int i = 0; i < sd.size(); i++) {
if (sd[i].get("shape") == previous_shape) {
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd.duplicate());
sd.remove(i);
break;
}
}
Fix problems with concave shapes in the TileSet editor (cherry picked from commit eeb972faefc988833693faea77d81cc8d2d2d2b4)
2020-02-11 22:31:25 +01:00
undo_redo->add_do_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd);
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), edited_collision_shape, Transform2D(), false, edited_shape_coord);
} else {
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), edited_collision_shape, Transform2D());
}
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_update_toggle_shape_button();
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
} else if (p_tool == SELECT_NEXT) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_select_next_shape();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
} else if (p_tool == SELECT_PREVIOUS) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_select_previous_shape();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == SHAPE_DELETE) {
TileMap Fixes
2017-12-01 01:50:09 +01:00
if (creating_shape) {
creating_shape = false;
current_shape.resize(0);
workspace->update();
} else {
switch (edit_mode) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
case EDITMODE_REGION: {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
int t_id = get_current_tile();
if (workspace_mode == WORKSPACE_EDIT && t_id >= 0) {
undo_redo->create_action(TTR("Remove Tile"));
undo_redo->add_do_method(tileset.ptr(), "remove_tile", t_id);
_undo_tile_removal(t_id);
undo_redo->add_do_method(this, "_validate_current_tile_id");
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Rect2 tile_region = tileset->tile_get_region(get_current_tile());
Size2 tile_workspace_size = tile_region.position + tile_region.size;
if (tile_workspace_size.x > get_current_texture()->get_size().x || tile_workspace_size.y > get_current_texture()->get_size().y) {
undo_redo->add_do_method(this, "update_workspace_minsize");
undo_redo->add_undo_method(this, "update_workspace_minsize");
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
update_workspace_tile_mode();
} break;
TileMap Fixes
2017-12-01 01:50:09 +01:00
case EDITMODE_COLLISION: {
if (!edited_collision_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
// Necessary to get the version that returns a Array instead of a Vector.
Array sd = tileset->call("tile_get_shapes", get_current_tile());
TileMap Fixes
2017-12-01 01:50:09 +01:00
for (int i = 0; i < sd.size(); i++) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (sd[i].get("shape") == edited_collision_shape) {
undo_redo->create_action(TTR("Remove Collision Polygon"));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd.duplicate());
sd.remove(i);
undo_redo->add_do_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd);
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
break;
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
} break;
case EDITMODE_OCCLUSION: {
if (!edited_occlusion_shape.is_null()) {
undo_redo->create_action(TTR("Remove Occlusion Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
undo_redo->add_do_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), Ref<OccluderPolygon2D>());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), tileset->tile_get_light_occluder(get_current_tile()));
} else {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), tileset->autotile_get_light_occluder(get_current_tile(), edited_shape_coord), edited_shape_coord);
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
} break;
case EDITMODE_NAVIGATION: {
if (!edited_navigation_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Remove Navigation Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
undo_redo->add_do_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), Ref<NavigationPolygon>());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), tileset->tile_get_navigation_polygon(get_current_tile()));
} else {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), Ref<NavigationPolygon>(), edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), tileset->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord), edited_shape_coord);
}
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Fix a random crash in the TileSet editor Occurred when selecting polygon collision mode, then drawing a single point, then selecting rectangle mode, and finally trying to select a rectangle. (cherry picked from commit 7850d0316f1100eb0f6b4229fb76784ea20a3e75)
2020-06-17 20:55:11 +02:00
} else if (p_tool == TOOL_SELECT || p_tool == SHAPE_NEW_POLYGON || p_tool == SHAPE_NEW_RECTANGLE) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
// Cancel Creation
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
creating_shape = false;
current_shape.resize(0);
workspace->update();
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_priority_changed(float val) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if ((int)val == tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord)) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Tile Priority"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_subtile_priority", get_current_tile(), edited_shape_coord, (int)val);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_subtile_priority", get_current_tile(), edited_shape_coord, tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
void TileSetEditor::_on_z_index_changed(float val) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if ((int)val == tileset->autotile_get_z_index(get_current_tile(), edited_shape_coord)) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Tile Z Index"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_z_index", get_current_tile(), edited_shape_coord, (int)val);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_z_index", get_current_tile(), edited_shape_coord, tileset->autotile_get_z_index(get_current_tile(), edited_shape_coord));
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_grid_snap_toggled(bool p_val) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
helper->set_snap_options_visible(p_val);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Vector<Vector2> TileSetEditor::_get_collision_shape_points(const Ref<Shape2D> &p_shape) {
Ref<ConvexPolygonShape2D> convex = p_shape;
Ref<ConcavePolygonShape2D> concave = p_shape;
if (convex.is_valid()) {
return convex->get_points();
} else if (concave.is_valid()) {
Vector<Vector2> points;
for (int i = 0; i < concave->get_segments().size(); i += 2) {
points.push_back(concave->get_segments()[i]);
}
return points;
} else {
return Vector<Vector2>();
}
}
Vector<Vector2> TileSetEditor::_get_edited_shape_points() {
return _get_collision_shape_points(edited_collision_shape);
}
Use reference to constant in functions
2019-07-10 11:54:12 +02:00
void TileSetEditor::_set_edited_shape_points(const Vector<Vector2> &points) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Ref<ConvexPolygonShape2D> convex = edited_collision_shape;
Ref<ConcavePolygonShape2D> concave = edited_collision_shape;
if (convex.is_valid()) {
undo_redo->add_do_method(convex.ptr(), "set_points", points);
undo_redo->add_undo_method(convex.ptr(), "set_points", _get_edited_shape_points());
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
} else if (concave.is_valid() && points.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
PoolVector2Array segments;
for (int i = 0; i < points.size() - 1; i++) {
segments.push_back(points[i]);
segments.push_back(points[i + 1]);
}
segments.push_back(points[points.size() - 1]);
segments.push_back(points[0]);
undo_redo->add_do_method(concave.ptr(), "set_segments", segments);
undo_redo->add_undo_method(concave.ptr(), "set_segments", concave->get_segments());
}
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
void TileSetEditor::_update_tile_data() {
current_tile_data.clear();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (get_current_tile() < 0) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(get_current_tile());
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
SubtileData data;
for (int i = 0; i < sd.size(); i++) {
data.collisions.push_back(sd[i].shape);
}
data.navigation_shape = tileset->tile_get_navigation_polygon(get_current_tile());
data.occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
current_tile_data[Vector2i()] = data;
} else {
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
Vector2 cell_count = _get_subtiles_count(get_current_tile());
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
for (int y = 0; y < cell_count.y; y++) {
for (int x = 0; x < cell_count.x; x++) {
SubtileData data;
Vector2i coord(x, y);
for (int i = 0; i < sd.size(); i++) {
if (sd[i].autotile_coord == coord) {
data.collisions.push_back(sd[i].shape);
}
}
data.navigation_shape = tileset->autotile_get_navigation_polygon(get_current_tile(), coord);
data.occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
current_tile_data[coord] = data;
}
}
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
void TileSetEditor::_update_toggle_shape_button() {
Ref<ConvexPolygonShape2D> convex = edited_collision_shape;
Ref<ConcavePolygonShape2D> concave = edited_collision_shape;
separator_shape_toggle->show();
tools[SHAPE_TOGGLE_TYPE]->show();
if (edit_mode != EDITMODE_COLLISION || !edited_collision_shape.is_valid()) {
separator_shape_toggle->hide();
tools[SHAPE_TOGGLE_TYPE]->hide();
} else if (concave.is_valid()) {
tools[SHAPE_TOGGLE_TYPE]->set_icon(get_icon("ConvexPolygonShape2D", "EditorIcons"));
Makes more editor strings translatable * Title of Sprite Editor convert preview dialogs * Title of UV Channel Debug dialog * Various editor warnings * GridMap popup menu item "Paste Selects" * Tileset editor shape button texts * MeshLibrary update confirmation text
2019-12-27 03:31:55 +01:00
tools[SHAPE_TOGGLE_TYPE]->set_text(TTR("Make Convex"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
} else if (convex.is_valid()) {
tools[SHAPE_TOGGLE_TYPE]->set_icon(get_icon("ConcavePolygonShape2D", "EditorIcons"));
Makes more editor strings translatable * Title of Sprite Editor convert preview dialogs * Title of UV Channel Debug dialog * Various editor warnings * GridMap popup menu item "Paste Selects" * Tileset editor shape button texts * MeshLibrary update confirmation text
2019-12-27 03:31:55 +01:00
tools[SHAPE_TOGGLE_TYPE]->set_text(TTR("Make Concave"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
} else {
Fix typos with codespell Using codespell 1.15.0. Method: ``` $ cat > ../godot-word-whitelist.txt << EOF ang curvelinear doubleclick leapyear lod merchantibility nd numer ois ony que seeked synching te uint unselect webp EOF $ codespell -w -q 3 -I ../godot-word-whitelist.txt --skip="./thirdparty,*.po" $ git diff // undo unwanted changes ```
2019-05-19 12:34:40 +02:00
// Shouldn't happen
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
separator_shape_toggle->hide();
tools[SHAPE_TOGGLE_TYPE]->hide();
}
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
void TileSetEditor::_select_next_tile() {
Array tiles = _get_tiles_in_current_texture(true);
if (tiles.size() == 0) {
set_current_tile(-1);
} else if (get_current_tile() == -1) {
set_current_tile(tiles[0]);
} else {
int index = tiles.find(get_current_tile());
if (index < 0) {
set_current_tile(tiles[0]);
} else if (index == tiles.size() - 1) {
set_current_tile(tiles[0]);
} else {
set_current_tile(tiles[index + 1]);
}
}
if (get_current_tile() == -1) {
return;
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
return;
} else {
switch (edit_mode) {
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
edited_shape_coord = Vector2();
_select_edited_shape_coord();
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
}
}
}
void TileSetEditor::_select_previous_tile() {
Array tiles = _get_tiles_in_current_texture(true);
if (tiles.size() == 0) {
set_current_tile(-1);
} else if (get_current_tile() == -1) {
set_current_tile(tiles[tiles.size() - 1]);
} else {
int index = tiles.find(get_current_tile());
if (index <= 0) {
set_current_tile(tiles[tiles.size() - 1]);
} else {
set_current_tile(tiles[index - 1]);
}
}
if (get_current_tile() == -1) {
return;
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
return;
} else {
switch (edit_mode) {
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
edited_shape_coord = _get_subtiles_count(get_current_tile()) - Vector2(1, 1);
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
_select_edited_shape_coord();
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
}
}
}
Array TileSetEditor::_get_tiles_in_current_texture(bool sorted) {
Array a;
List<int> all_tiles;
if (!get_current_texture().is_valid()) {
return a;
}
tileset->get_tile_list(&all_tiles);
for (int i = 0; i < all_tiles.size(); i++) {
if (tileset->tile_get_texture(all_tiles[i]) == get_current_texture()) {
a.push_back(all_tiles[i]);
}
}
if (sorted) {
a.sort_custom(this, "_sort_tiles");
}
return a;
}
bool TileSetEditor::_sort_tiles(Variant p_a, Variant p_b) {
int a = p_a;
int b = p_b;
Vector2 pos_a = tileset->tile_get_region(a).position;
Vector2 pos_b = tileset->tile_get_region(b).position;
if (pos_a.y < pos_b.y) {
return true;
} else if (pos_a.y == pos_b.y) {
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02:00
return (pos_a.x < pos_b.x);
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
} else {
return false;
}
}
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
Vector2 TileSetEditor::_get_subtiles_count(int p_tile_id) {
const int spacing = tileset->autotile_get_spacing(p_tile_id);
const Vector2 region_size = tileset->tile_get_region(p_tile_id).size;
const Vector2 subtile_size = tileset->autotile_get_size(p_tile_id);
// In case of not perfect fit the last row/column is allowed to exceed the tile region.
// The return value is the biggest integer-only `(m, n)` satisfying the formula:
// (m, n) * subtile_size + (m - 1, n - 1) * spacing < region_size + subtile_size
Vector2 mn = Vector2(1, 1) + (region_size / (subtile_size + Vector2(spacing, spacing)));
return mn == mn.floor() ? mn.floor() - Vector2(1, 1) : mn.floor();
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
void TileSetEditor::_select_next_subtile() {
if (get_current_tile() == -1) {
_select_next_tile();
return;
}
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
_select_next_tile();
} else if (edit_mode == EDITMODE_REGION || edit_mode == EDITMODE_BITMASK || edit_mode == EDITMODE_ICON) {
_select_next_tile();
} else {
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
Vector2 cell_count = _get_subtiles_count(get_current_tile());
if (edited_shape_coord.x >= cell_count.x - 1 && edited_shape_coord.y >= cell_count.y - 1) {
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
_select_next_tile();
} else {
edited_shape_coord.x++;
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
if (edited_shape_coord.x > cell_count.x - 1) {
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
edited_shape_coord.x = 0;
edited_shape_coord.y++;
}
_select_edited_shape_coord();
}
}
}
void TileSetEditor::_select_previous_subtile() {
if (get_current_tile() == -1) {
_select_previous_tile();
return;
}
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
_select_previous_tile();
} else if (edit_mode == EDITMODE_REGION || edit_mode == EDITMODE_BITMASK || edit_mode == EDITMODE_ICON) {
_select_previous_tile();
} else {
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
Vector2 cell_count = _get_subtiles_count(get_current_tile());
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
if (edited_shape_coord.x <= 0 && edited_shape_coord.y <= 0) {
_select_previous_tile();
} else {
edited_shape_coord.x--;
TileSetEditor Fix selecting next/previous subtile
2021-11-23 14:49:37 +01:00
if (edited_shape_coord.x < 0) {
edited_shape_coord.x = cell_count.x - 1;
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
edited_shape_coord.y--;
}
_select_edited_shape_coord();
}
}
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
void TileSetEditor::_select_next_shape() {
if (get_current_tile() == -1) {
_select_next_subtile();
} else if (edit_mode != EDITMODE_COLLISION) {
_select_next_subtile();
} else {
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 10:11:05 +02:00
Vector2i edited_coord = Vector2i();
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) != TileSet::SINGLE_TILE) {
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 10:11:05 +02:00
edited_coord = Vector2i(edited_shape_coord);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
SubtileData data = current_tile_data[edited_coord];
if (data.collisions.size() == 0) {
_select_next_subtile();
} else {
int index = data.collisions.find(edited_collision_shape);
if (index < 0) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[0]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
} else if (index == data.collisions.size() - 1) {
_select_next_subtile();
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[index + 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
current_shape.resize(0);
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
current_tile_region.position += shape_anchor;
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
}
void TileSetEditor::_select_previous_shape() {
if (get_current_tile() == -1) {
_select_previous_subtile();
if (get_current_tile() != -1 && edit_mode == EDITMODE_COLLISION) {
SubtileData data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
return;
}
} else if (edit_mode != EDITMODE_COLLISION) {
_select_previous_subtile();
} else {
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 10:11:05 +02:00
Vector2i edited_coord = Vector2i();
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) != TileSet::SINGLE_TILE) {
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 10:11:05 +02:00
edited_coord = Vector2i(edited_shape_coord);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
SubtileData data = current_tile_data[edited_coord];
if (data.collisions.size() == 0) {
_select_previous_subtile();
data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
int index = data.collisions.find(edited_collision_shape);
if (index < 0) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
} else if (index == 0) {
_select_previous_subtile();
data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[index - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
current_shape.resize(0);
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
current_tile_region.position += shape_anchor;
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
void TileSetEditor::_set_edited_collision_shape(const Ref<Shape2D> &p_shape) {
edited_collision_shape = p_shape;
_update_toggle_shape_button();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_step(Vector2 p_val) {
Increase the TileSet editor's snap step to 1024 This also tweaks the autotile bitmaks mode property hint string.
2021-05-18 23:38:22 +02:00
snap_step.x = CLAMP(p_val.x, 1, 1024);
snap_step.y = CLAMP(p_val.y, 1, 1024);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_off(Vector2 p_val) {
Increase the TileSet editor's snap step to 1024 This also tweaks the autotile bitmaks mode property hint string.
2021-05-18 23:38:22 +02:00
snap_offset.x = CLAMP(p_val.x, 0, 1024 + WORKSPACE_MARGIN.x);
snap_offset.y = CLAMP(p_val.y, 0, 1024 + WORKSPACE_MARGIN.y);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_sep(Vector2 p_val) {
Increase the TileSet editor's snap step to 1024 This also tweaks the autotile bitmaks mode property hint string.
2021-05-18 23:38:22 +02:00
snap_separation.x = CLAMP(p_val.x, 0, 1024);
snap_separation.y = CLAMP(p_val.y, 0, 1024);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
void TileSetEditor::_validate_current_tile_id() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (get_current_tile() >= 0 && !tileset->has_tile(get_current_tile())) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
set_current_tile(-1);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
void TileSetEditor::_select_edited_shape_coord() {
select_coord(edited_shape_coord);
}
void TileSetEditor::_undo_tile_removal(int p_id) {
undo_redo->add_undo_method(tileset.ptr(), "create_tile", p_id);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_name", p_id, tileset->tile_get_name(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_normal_map", p_id, tileset->tile_get_normal_map(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_texture_offset", p_id, tileset->tile_get_texture_offset(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_material", p_id, tileset->tile_get_material(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_modulate", p_id, tileset->tile_get_modulate(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_occluder_offset", p_id, tileset->tile_get_occluder_offset(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon_offset", p_id, tileset->tile_get_navigation_polygon_offset(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shape_offset", p_id, 0, tileset->tile_get_shape_offset(p_id, 0));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shape_transform", p_id, 0, tileset->tile_get_shape_transform(p_id, 0));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_z_index", p_id, tileset->tile_get_z_index(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_texture", p_id, tileset->tile_get_texture(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_region", p_id, tileset->tile_get_region(p_id));
// Necessary to get the version that returns a Array instead of a Vector.
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", p_id, tileset->call("tile_get_shapes", p_id));
if (tileset->tile_get_tile_mode(p_id) == TileSet::SINGLE_TILE) {
undo_redo->add_undo_method(tileset.ptr(), "tile_set_light_occluder", p_id, tileset->tile_get_light_occluder(p_id));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon", p_id, tileset->tile_get_navigation_polygon(p_id));
} else {
Style: Set clang-format Standard to c++14
2021-05-04 14:20:36 +02:00
Map<Vector2, Ref<OccluderPolygon2D>> oclusion_map = tileset->autotile_get_light_oclusion_map(p_id);
for (Map<Vector2, Ref<OccluderPolygon2D>>::Element *E = oclusion_map.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", p_id, E->value(), E->key());
}
Style: Set clang-format Standard to c++14
2021-05-04 14:20:36 +02:00
Map<Vector2, Ref<NavigationPolygon>> navigation_map = tileset->autotile_get_navigation_map(p_id);
for (Map<Vector2, Ref<NavigationPolygon>>::Element *E = navigation_map.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_navigation_polygon", p_id, E->value(), E->key());
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
Map<Vector2, uint32_t> bitmask_map = tileset->autotile_get_bitmask_map(p_id);
for (Map<Vector2, uint32_t>::Element *E = bitmask_map.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", p_id, E->key(), E->value());
}
Map<Vector2, int> priority_map = tileset->autotile_get_priority_map(p_id);
for (Map<Vector2, int>::Element *E = priority_map.front(); E; E = E->next()) {
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_subtile_priority", p_id, E->key(), E->value());
}
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_icon_coordinate", p_id, tileset->autotile_get_icon_coordinate(p_id));
Map<Vector2, int> z_map = tileset->autotile_get_z_index_map(p_id);
for (Map<Vector2, int>::Element *E = z_map.front(); E; E = E->next()) {
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_z_index", p_id, E->key(), E->value());
}
undo_redo->add_undo_method(tileset.ptr(), "tile_set_tile_mode", p_id, tileset->tile_get_tile_mode(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_size", p_id, tileset->autotile_get_size(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_spacing", p_id, tileset->autotile_get_spacing(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask_mode", p_id, tileset->autotile_get_bitmask_mode(p_id));
}
}
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
void TileSetEditor::_zoom_in() {
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
_zoom_on_position(scale_ratio, Vector2());
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
}
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
void TileSetEditor::_zoom_out() {
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
_zoom_on_position(1 / scale_ratio, Vector2());
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
}
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
void TileSetEditor::_zoom_reset() {
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
workspace->set_scale(Vector2(1, 1));
workspace_container->set_custom_minimum_size(workspace->get_rect().size);
workspace_overlay->set_custom_minimum_size(workspace->get_rect().size);
}
Update scroll position when zooming TileSet editor
2022-03-07 06:01:39 +01:00
void TileSetEditor::_zoom_on_position(float p_zoom, const Vector2 &p_position) {
const float old_scale = workspace->get_scale().x;
const float new_scale = CLAMP(old_scale * p_zoom, min_scale, max_scale);
workspace->set_scale(Vector2(new_scale, new_scale));
workspace_container->set_custom_minimum_size(workspace->get_rect().size * new_scale);
workspace_overlay->set_custom_minimum_size(workspace->get_rect().size * new_scale);
Vector2 offset = Vector2(scroll->get_h_scroll(), scroll->get_v_scroll());
offset = (offset + p_position) / old_scale * new_scale - p_position;
scroll->set_h_scroll(offset.x);
scroll->set_v_scroll(offset.y);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::draw_highlight_current_tile() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color shadow_color = Color(0.3, 0.3, 0.3, 0.3);
if ((workspace_mode == WORKSPACE_EDIT && get_current_tile() >= 0) || !edited_region.has_no_area()) {
Rect2 region;
if (edited_region.has_no_area()) {
region = tileset->tile_get_region(get_current_tile());
region.position += WORKSPACE_MARGIN;
} else {
region = edited_region;
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (region.position.y >= 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, 0, workspace->get_rect().size.x, region.position.y), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (region.position.x >= 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, MAX(0, region.position.y), region.position.x, MIN(workspace->get_rect().size.y - region.position.y, MIN(region.size.y, region.position.y + region.size.y))), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (region.position.x + region.size.x <= workspace->get_rect().size.x) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(region.position.x + region.size.x, MAX(0, region.position.y), workspace->get_rect().size.x - region.position.x - region.size.x, MIN(workspace->get_rect().size.y - region.position.y, MIN(region.size.y, region.position.y + region.size.y))), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (region.position.y + region.size.y <= workspace->get_rect().size.y) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, region.position.y + region.size.y, workspace->get_rect().size.x, workspace->get_rect().size.y - region.size.y - region.position.y), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(Point2(0, 0), workspace->get_rect().size), shadow_color);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::draw_highlight_subtile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color shadow_color = Color(0.3, 0.3, 0.3, 0.3);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 size = tileset->autotile_get_size(get_current_tile());
int spacing = tileset->autotile_get_spacing(get_current_tile());
Rect2 region = tileset->tile_get_region(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
coord += region.position;
coord += WORKSPACE_MARGIN;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (coord.y >= 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, 0, workspace->get_rect().size.x, coord.y), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (coord.x >= 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, MAX(0, coord.y), coord.x, MIN(workspace->get_rect().size.y - coord.y, MIN(size.y, coord.y + size.y))), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (coord.x + size.x <= workspace->get_rect().size.x) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(coord.x + size.x, MAX(0, coord.y), workspace->get_rect().size.x - coord.x - size.x, MIN(workspace->get_rect().size.y - coord.y, MIN(size.y, coord.y + size.y))), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (coord.y + size.y <= workspace->get_rect().size.y) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(0, coord.y + size.y, workspace->get_rect().size.x, workspace->get_rect().size.y - size.y - coord.y), shadow_color);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
TileSetEditorPlugin: take scale in accout when highlighting current selected subtile.
2018-01-18 01:07:43 +01:00
coord += Vector2(1, 1) / workspace->get_scale().x;
workspace->draw_rect(Rect2(coord, size - Vector2(2, 2) / workspace->get_scale().x), Color(1, 0, 0), false);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < other_highlighted.size(); i++) {
coord = other_highlighted[i];
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
coord += region.position;
coord += WORKSPACE_MARGIN;
TileSetEditorPlugin: take scale in accout when highlighting current selected subtile.
2018-01-18 01:07:43 +01:00
coord += Vector2(1, 1) / workspace->get_scale().x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(Rect2(coord, size - Vector2(2, 2) / workspace->get_scale().x), Color(1, 0.5, 0.5), false);
}
}
void TileSetEditor::draw_tile_subdivision(int p_id, Color p_color) const {
Color c = p_color;
if (tileset->tile_get_tile_mode(p_id) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(p_id) == TileSet::ATLAS_TILE) {
Rect2 region = tileset->tile_get_region(p_id);
Size2 size = tileset->autotile_get_size(p_id);
int spacing = tileset->autotile_get_spacing(p_id);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
float j = size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.x) {
if (spacing <= 0) {
workspace->draw_line(region.position + WORKSPACE_MARGIN + Point2(j, 0), region.position + WORKSPACE_MARGIN + Point2(j, region.size.y), c);
} else {
workspace->draw_rect(Rect2(region.position + WORKSPACE_MARGIN + Point2(j, 0), Size2(spacing, region.size.y)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j = size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.y) {
if (spacing <= 0) {
workspace->draw_line(region.position + WORKSPACE_MARGIN + Point2(0, j), region.position + WORKSPACE_MARGIN + Point2(region.size.x, j), c);
} else {
workspace->draw_rect(Rect2(region.position + WORKSPACE_MARGIN + Point2(0, j), Size2(region.size.x, spacing)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
}
void TileSetEditor::draw_edited_region_subdivision() const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color c = Color(0.3, 0.7, 0.6);
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 region = edited_region;
Size2 size;
int spacing;
bool draw;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode == WORKSPACE_EDIT) {
int p_id = get_current_tile();
size = tileset->autotile_get_size(p_id);
spacing = tileset->autotile_get_spacing(p_id);
draw = tileset->tile_get_tile_mode(p_id) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(p_id) == TileSet::ATLAS_TILE;
} else {
size = snap_step;
spacing = snap_separation.x;
draw = workspace_mode != WORKSPACE_CREATE_SINGLE;
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (draw) {
float j = size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.x) {
if (spacing <= 0) {
workspace->draw_line(region.position + Point2(j, 0), region.position + Point2(j, region.size.y), c);
} else {
workspace->draw_rect(Rect2(region.position + Point2(j, 0), Size2(spacing, region.size.y)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j = size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.y) {
if (spacing <= 0) {
workspace->draw_line(region.position + Point2(0, j), region.position + Point2(region.size.x, j), c);
} else {
workspace->draw_rect(Rect2(region.position + Point2(0, j), Size2(region.size.x, spacing)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::draw_grid_snap() {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color grid_color = Color(0.4, 0, 1);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
Size2 s = workspace->get_size();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
int width_count = Math::floor((s.width - WORKSPACE_MARGIN.x) / (snap_step.x + snap_separation.x));
int height_count = Math::floor((s.height - WORKSPACE_MARGIN.y) / (snap_step.y + snap_separation.y));
Autotile Enhancement
2017-12-28 06:57:37 +01:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
int last_p = 0;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (snap_step.x != 0) {
for (int i = 0; i <= width_count; i++) {
if (i == 0 && snap_offset.x != 0) {
last_p = snap_offset.x;
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (snap_separation.x != 0) {
if (i != 0) {
workspace->draw_rect(Rect2(last_p, 0, snap_separation.x, s.height), grid_color);
last_p += snap_separation.x;
} else {
workspace->draw_rect(Rect2(last_p, 0, -snap_separation.x, s.height), grid_color);
}
} else {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->draw_line(Point2(last_p, 0), Point2(last_p, s.height), grid_color);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
last_p += snap_step.x;
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
last_p = 0;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (snap_step.y != 0) {
for (int i = 0; i <= height_count; i++) {
if (i == 0 && snap_offset.y != 0) {
last_p = snap_offset.y;
}
Fix TilesetEditorContext separation snap. Fixes #34182
2019-12-08 00:29:35 +01:00
if (snap_separation.y != 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (i != 0) {
workspace->draw_rect(Rect2(0, last_p, s.width, snap_separation.y), grid_color);
last_p += snap_separation.y;
} else {
workspace->draw_rect(Rect2(0, last_p, s.width, -snap_separation.y), grid_color);
}
} else {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->draw_line(Point2(0, last_p), Point2(s.width, last_p), grid_color);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
last_p += snap_step.y;
}
}
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::draw_polygon_shapes() {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
int t_id = get_current_tile();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (t_id < 0) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
switch (edit_mode) {
case EDITMODE_COLLISION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(t_id);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < sd.size(); i++) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = Vector2(0, 0);
Vector2 anchor = Vector2(0, 0);
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
coord = sd[i].autotile_coord;
anchor = tileset->autotile_get_size(t_id);
anchor.x += tileset->autotile_get_spacing(t_id);
anchor.y += tileset->autotile_get_spacing(t_id);
anchor.x *= coord.x;
anchor.y *= coord.y;
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Ref<Shape2D> shape = sd[i].shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Color c_bg;
Color c_border;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Ref<ConvexPolygonShape2D> convex = shape;
bool is_convex = convex.is_valid();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if ((tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE || coord == edited_shape_coord) && sd[i].shape == edited_collision_shape) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
if (is_convex) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.8, 0, 1, 0.5);
c_border = Color(0.8, 0, 1);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
if (is_convex) {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
} else {
c_bg = Color(0.9, 0.45, 0.075, 0.5);
c_border = Color(0.9, 0.45, 0.075);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_collision_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int j = 0; j < _get_collision_shape_points(shape).size(); j++) {
polygon.push_back(_get_collision_shape_points(shape)[j] + anchor);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
colors.push_back(c_bg);
}
}
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 16:45:18 +02:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (polygon.size() < 3) {
Update tile_set_editor_plugin.cpp
2019-03-27 18:20:52 +01:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 16:45:18 +02:00
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (!creating_shape && polygon.size() > 1) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
for (int j = 0; j < polygon.size() - 1; j++) {
workspace->draw_line(polygon[j], polygon[j + 1], c_border, 1, true);
}
workspace->draw_line(polygon[polygon.size() - 1], polygon[0], c_border, 1, true);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
if (shape == edited_collision_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
} break;
case EDITMODE_OCCLUSION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Ref<OccluderPolygon2D> shape = edited_occlusion_shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> polygon;
Vector<Color> colors;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
Vector2 anchor = WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(get_current_tile()).position;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
for (int j = 0; j < shape->get_polygon().size(); j++) {
polygon.push_back(shape->get_polygon()[j] + anchor);
colors.push_back(c_bg);
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (!creating_shape && polygon.size() > 1) {
for (int j = 0; j < polygon.size() - 1; j++) {
workspace->draw_line(polygon[j], polygon[j + 1], c_border, 1, true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
workspace->draw_line(polygon[polygon.size() - 1], polygon[0], c_border, 1, true);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
} else {
Style: Set clang-format Standard to c++14
2021-05-04 14:20:36 +02:00
Map<Vector2, Ref<OccluderPolygon2D>> map = tileset->autotile_get_light_oclusion_map(t_id);
for (Map<Vector2, Ref<OccluderPolygon2D>>::Element *E = map.front(); E; E = E->next()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = E->key();
Vector2 anchor = tileset->autotile_get_size(t_id);
anchor.x += tileset->autotile_get_spacing(t_id);
anchor.y += tileset->autotile_get_spacing(t_id);
anchor.x *= coord.x;
anchor.y *= coord.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Ref<OccluderPolygon2D> shape = E->value();
if (shape.is_valid()) {
Color c_bg;
Color c_border;
if (coord == edited_shape_coord && shape == edited_occlusion_shape) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int j = 0; j < current_shape.size(); j++) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
for (int j = 0; j < shape->get_polygon().size(); j++) {
polygon.push_back(shape->get_polygon()[j] + anchor);
colors.push_back(c_bg);
}
}
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord) {
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (!creating_shape && polygon.size() > 1) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
for (int j = 0; j < polygon.size() - 1; j++) {
workspace->draw_line(polygon[j], polygon[j + 1], c_border, 1, true);
}
workspace->draw_line(polygon[polygon.size() - 1], polygon[0], c_border, 1, true);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
}
} break;
case EDITMODE_NAVIGATION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Ref<NavigationPolygon> shape = edited_navigation_shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> polygon;
Vector<Color> colors;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
Vector2 anchor = WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(get_current_tile()).position;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
for (int outline_idx = 0; outline_idx < shape->get_outline_count(); outline_idx++) {
PoolVector<Vector2> outline_vertices = shape->get_outline(outline_idx);
for (int vertex_idx = 0; vertex_idx < outline_vertices.size(); vertex_idx++) {
polygon.push_back(outline_vertices[vertex_idx] + anchor);
}
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
}
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
colors.resize(polygon.size());
colors.fill(c_bg);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (!creating_shape && polygon.size() > 1) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
for (int j = 0; j < polygon.size() - 1; j++) {
workspace->draw_line(polygon[j], polygon[j + 1], c_border, 1, true);
}
workspace->draw_line(polygon[polygon.size() - 1], polygon[0], c_border, 1, true);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
} else {
Style: Set clang-format Standard to c++14
2021-05-04 14:20:36 +02:00
Map<Vector2, Ref<NavigationPolygon>> map = tileset->autotile_get_navigation_map(t_id);
for (Map<Vector2, Ref<NavigationPolygon>>::Element *E = map.front(); E; E = E->next()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = E->key();
Vector2 anchor = tileset->autotile_get_size(t_id);
anchor.x += tileset->autotile_get_spacing(t_id);
anchor.y += tileset->autotile_get_spacing(t_id);
anchor.x *= coord.x;
anchor.y *= coord.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Ref<NavigationPolygon> shape = E->value();
if (shape.is_valid()) {
Color c_bg;
Color c_border;
if (coord == edited_shape_coord && shape == edited_navigation_shape) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
}
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
} else {
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
for (int outline_idx = 0; outline_idx < shape->get_outline_count(); outline_idx++) {
PoolVector<Vector2> outline_vertices = shape->get_outline(outline_idx);
for (int vertex_idx = 0; vertex_idx < outline_vertices.size(); vertex_idx++) {
polygon.push_back(outline_vertices[vertex_idx] + anchor);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
colors.resize(polygon.size());
colors.fill(c_bg);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord) {
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (!creating_shape && polygon.size() > 1) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
for (int j = 0; j < polygon.size() - 1; j++) {
workspace->draw_line(polygon[j], polygon[j + 1], c_border, 1, true);
}
workspace->draw_line(polygon[polygon.size() - 1], polygon[0], c_border, 1, true);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
TileSet Editor: Check polygon size before indexing Fixes #39722. (cherry picked from commit 6f428f24946a15ee8c6df2ccb599f017b2faaa2a)
2020-07-21 08:05:51 +02:00
if (creating_shape && current_shape.size() > 1) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int j = 0; j < current_shape.size() - 1; j++) {
workspace->draw_line(current_shape[j], current_shape[j + 1], Color(0, 1, 1), 1, true);
}
workspace->draw_line(current_shape[current_shape.size() - 1], snap_point(workspace->get_local_mouse_position()), Color(0, 1, 1), 1, true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::close_shape(const Vector2 &shape_anchor) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
creating_shape = false;
if (edit_mode == EDITMODE_COLLISION) {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (current_shape.size() >= 3) {
Ref<ConvexPolygonShape2D> shape = memnew(ConvexPolygonShape2D);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Vector<Vector2> points;
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
float p_total = 0;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Autotile Enhancement
2017-12-28 06:57:37 +01:00
for (int i = 0; i < current_shape.size(); i++) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
points.push_back(current_shape[i] - shape_anchor);
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (i != current_shape.size() - 1) {
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
p_total += ((current_shape[i + 1].x - current_shape[i].x) * (-current_shape[i + 1].y + (-current_shape[i].y)));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
p_total += ((current_shape[0].x - current_shape[i].x) * (-current_shape[0].y + (-current_shape[i].y)));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (p_total < 0) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
points.invert();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
shape->set_points(points);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Collision Polygon"));
// Necessary to get the version that returns a Array instead of a Vector.
Array sd = tileset->call("tile_get_shapes", get_current_tile());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd.duplicate());
for (int i = 0; i < sd.size(); i++) {
if (sd[i].get("shape") == edited_collision_shape) {
sd.remove(i);
break;
}
}
undo_redo->add_do_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), shape, Transform2D());
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
tools[TOOL_SELECT]->set_pressed(true);
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
} else {
tools[TOOL_SELECT]->set_pressed(true);
workspace->update();
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
Ref<OccluderPolygon2D> shape = memnew(OccluderPolygon2D);
PoolVector<Vector2> polygon;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
}
Added release function to PoolVector::Access. For clarity, assign-to-release idiom for PoolVector::Read/Write replaced with a function call. Existing uses replaced (or removed if already handled by scope)
2019-07-05 19:08:43 +02:00
w.release();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
shape->set_polygon(polygon);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Occlusion Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), shape, edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), tileset->autotile_get_light_occluder(get_current_tile(), edited_shape_coord), edited_shape_coord);
} else {
undo_redo->add_do_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), shape);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), tileset->tile_get_light_occluder(get_current_tile()));
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (edit_mode == EDITMODE_NAVIGATION) {
Ref<NavigationPolygon> shape = memnew(NavigationPolygon);
PoolVector<Vector2> polygon;
Vector<int> indices;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
indices.push_back(i);
}
Added release function to PoolVector::Access. For clarity, assign-to-release idiom for PoolVector::Read/Write replaced with a function call. Existing uses replaced (or removed if already handled by scope)
2019-07-05 19:08:43 +02:00
w.release();
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
shape->clear_outlines();
shape->add_outline(polygon);
shape->make_polygons_from_outlines();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Navigation Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), shape, edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), tileset->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord), edited_shape_coord);
} else {
undo_redo->add_do_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), shape);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), tileset->tile_get_navigation_polygon(get_current_tile()));
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->_change_notify("");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::select_coord(const Vector2 &coord) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_update_tile_data();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
current_shape = PoolVector2Array();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (get_current_tile() == -1) {
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (edited_collision_shape != tileset->tile_get_shape(get_current_tile(), 0)) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(tileset->tile_get_shape(get_current_tile(), 0));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (edited_occlusion_shape != tileset->tile_get_light_occluder(get_current_tile())) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
edited_occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (edited_navigation_shape != tileset->tile_get_navigation_polygon(get_current_tile())) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
edited_navigation_shape = tileset->tile_get_navigation_polygon(get_current_tile());
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (edit_mode == EDITMODE_COLLISION) {
current_shape.resize(0);
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
current_shape.resize(0);
if (edited_occlusion_shape.is_valid()) {
for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
} else if (edit_mode == EDITMODE_NAVIGATION) {
current_shape.resize(0);
if (edited_navigation_shape.is_valid()) {
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
for (int outline_idx = 0; outline_idx < edited_navigation_shape->get_outline_count(); outline_idx++) {
PoolVector<Vector2> outline_vertices = edited_navigation_shape->get_outline(outline_idx);
for (int vertex_inx = 0; vertex_inx < outline_vertices.size(); vertex_inx++) {
current_shape.push_back(outline_vertices[vertex_inx] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(get_current_tile());
bool found_collision_shape = false;
for (int i = 0; i < sd.size(); i++) {
if (sd[i].autotile_coord == coord) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (edited_collision_shape != sd[i].shape) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(sd[i].shape);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
found_collision_shape = true;
break;
}
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (!found_collision_shape) {
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 16:00:45 +02:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>(nullptr));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (edited_occlusion_shape != tileset->autotile_get_light_occluder(get_current_tile(), coord)) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_occlusion_shape = tileset->autotile_get_light_occluder(get_current_tile(), coord);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (edited_navigation_shape != tileset->autotile_get_navigation_polygon(get_current_tile(), coord)) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_navigation_shape = tileset->autotile_get_navigation_polygon(get_current_tile(), coord);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
shape_anchor += current_tile_region.position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (edit_mode == EDITMODE_COLLISION) {
current_shape.resize(0);
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int j = 0; j < _get_edited_shape_points().size(); j++) {
current_shape.push_back(_get_edited_shape_points()[j] + shape_anchor);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
} else if (edit_mode == EDITMODE_OCCLUSION) {
current_shape.resize(0);
if (edited_occlusion_shape.is_valid()) {
for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + shape_anchor);
}
}
} else if (edit_mode == EDITMODE_NAVIGATION) {
current_shape.resize(0);
if (edited_navigation_shape.is_valid()) {
Fix TileSetEditor wrong NavigationPolygon format TileSets created and stored NavigationPolyons in a format that did not work for Navigation.
2022-05-22 00:41:40 +02:00
for (int outline_idx = 0; outline_idx < edited_navigation_shape->get_outline_count(); outline_idx++) {
PoolVector<Vector2> outline_vertices = edited_navigation_shape->get_outline(outline_idx);
for (int vertex_inx = 0; vertex_inx < outline_vertices.size(); vertex_inx++) {
current_shape.push_back(outline_vertices[vertex_inx] + shape_anchor);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
}
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
workspace_container->update();
helper->_change_notify("");
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 TileSetEditor::snap_point(const Vector2 &point) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 p = point;
Vector2 coord = edited_shape_coord;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 tile_size = tileset->autotile_get_size(get_current_tile());
int spacing = tileset->autotile_get_spacing(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 anchor = coord;
anchor.x *= (tile_size.x + spacing);
anchor.y *= (tile_size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += tileset->tile_get_region(get_current_tile()).position;
anchor += WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Rect2 region(anchor, tile_size);
Fixes the resize of tile shapes when a vertex is outside of the tilesheet. Fix #34970 (cherry picked from commit 5355169d3c3e911d0f1d3691858bf78f6195947f)
2020-09-18 01:03:52 +02:00
Rect2 tile_region(tileset->tile_get_region(get_current_tile()).position + WORKSPACE_MARGIN, tileset->tile_get_region(get_current_tile()).size);
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
region.position = tileset->tile_get_region(get_current_tile()).position + WORKSPACE_MARGIN;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
region.size = tileset->tile_get_region(get_current_tile()).size;
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
Fix "seperate" typos
2019-10-31 13:40:58 +01:00
p.x = Math::snap_scalar_separation(snap_offset.x, snap_step.x, p.x, snap_separation.x);
p.y = Math::snap_scalar_separation(snap_offset.y, snap_step.y, p.y, snap_separation.y);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
Fixes the resize of tile shapes when a vertex is outside of the tilesheet. Fix #34970 (cherry picked from commit 5355169d3c3e911d0f1d3691858bf78f6195947f)
2020-09-18 01:03:52 +02:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (p.x < region.position.x) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
p.x = region.position.x;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (p.y < region.position.y) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
p.y = region.position.y;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (p.x > region.position.x + region.size.x) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
p.x = region.position.x + region.size.x;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (p.y > region.position.y + region.size.y) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
p.y = region.position.y + region.size.y;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fixes the resize of tile shapes when a vertex is outside of the tilesheet. Fix #34970 (cherry picked from commit 5355169d3c3e911d0f1d3691858bf78f6195947f)
2020-09-18 01:03:52 +02:00
if (p.x < tile_region.position.x) {
p.x = tile_region.position.x;
}
if (p.y < tile_region.position.y) {
p.y = tile_region.position.y;
}
if (p.x > (tile_region.position.x + tile_region.size.x)) {
p.x = (tile_region.position.x + tile_region.size.x);
}
if (p.y > (tile_region.position.y + tile_region.size.y)) {
p.y = (tile_region.position.y + tile_region.size.y);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
return p;
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
void TileSetEditor::add_texture(Ref<Texture> p_texture) {
texture_list->add_item(p_texture->get_path().get_file());
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
texture_map.insert(p_texture->get_path(), p_texture);
texture_list->set_item_metadata(texture_list->get_item_count() - 1, p_texture->get_path());
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
void TileSetEditor::remove_texture(Ref<Texture> p_texture) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
texture_list->remove_item(texture_list->find_metadata(p_texture->get_path()));
texture_map.erase(p_texture->get_path());
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_validate_current_tile_id();
if (!get_current_texture().is_valid()) {
_on_texture_list_selected(-1);
workspace_overlay->update();
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::update_texture_list() {
Ref<Texture> selected_texture = get_current_texture();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
helper->set_tileset(tileset);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
List<int> ids;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->get_tile_list(&ids);
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
Vector<int> ids_to_remove;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
// Clear tiles referencing gone textures (user has been already given the chance to fix broken deps)
if (!tileset->tile_get_texture(E->get()).is_valid()) {
ids_to_remove.push_back(E->get());
ERR_CONTINUE(!tileset->tile_get_texture(E->get()).is_valid());
}
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
if (!texture_map.has(tileset->tile_get_texture(E->get())->get_path())) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
add_texture(tileset->tile_get_texture(E->get()));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
for (int i = 0; i < ids_to_remove.size(); i++) {
tileset->remove_tile(ids_to_remove[i]);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (texture_list->get_item_count() > 0 && selected_texture.is_valid()) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
texture_list->select(texture_list->find_metadata(selected_texture->get_path()));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (texture_list->get_selected_items().size() > 0) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
_on_texture_list_selected(texture_list->get_selected_items()[0]);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (get_current_texture().is_valid()) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
_on_texture_list_selected(texture_list->find_metadata(get_current_texture()->get_path()));
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_validate_current_tile_id();
New TileSet Editor
2018-07-29 23:54:12 +02:00
_on_texture_list_selected(-1);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
workspace_overlay->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
update_texture_list_icon();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
helper->_change_notify("");
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::update_texture_list_icon() {
for (int current_idx = 0; current_idx < texture_list->get_item_count(); current_idx++) {
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String path = texture_list->get_item_metadata(current_idx);
texture_list->set_item_icon(current_idx, texture_map[path]);
Size2 texture_size = texture_map[path]->get_size();
Fixed Tileset preview stretching textures
2019-03-05 03:35:49 +01:00
texture_list->set_item_icon_region(current_idx, Rect2(0, 0, MIN(texture_size.x, 150), MIN(texture_size.y, 100)));
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list->update();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditor::update_workspace_tile_mode() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (!get_current_texture().is_valid()) {
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
for (int i = 1; i < WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i]->set_disabled(true);
}
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_disabled(true);
tools[SELECT_PREVIOUS]->set_disabled(true);
Add informational messages to various editors
2019-09-04 07:20:57 +02:00
tools[ZOOM_OUT]->hide();
tools[ZOOM_1]->hide();
tools[ZOOM_IN]->hide();
tools[VISIBLE_INFO]->hide();
scroll->hide();
empty_message->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
} else {
for (int i = 1; i < WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i]->set_disabled(false);
}
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_disabled(false);
tools[SELECT_PREVIOUS]->set_disabled(false);
Add informational messages to various editors
2019-09-04 07:20:57 +02:00
tools[ZOOM_OUT]->show();
tools[ZOOM_1]->show();
tools[ZOOM_IN]->show();
tools[VISIBLE_INFO]->show();
scroll->show();
empty_message->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode != WORKSPACE_EDIT) {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
tool_editmode[EDITMODE_REGION]->show();
tool_editmode[EDITMODE_REGION]->set_pressed(true);
_on_edit_mode_changed(EDITMODE_REGION);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
}
if (get_current_tile() < 0) {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
for (int i = TOOL_SELECT; i < ZOOM_OUT; i++) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[i]->hide();
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->hide();
separator_grid->hide();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
return;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->show();
}
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
if (tool_editmode[EDITMODE_ICON]->is_pressed() || tool_editmode[EDITMODE_PRIORITY]->is_pressed() || tool_editmode[EDITMODE_BITMASK]->is_pressed() || tool_editmode[EDITMODE_Z_INDEX]->is_pressed()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
New TileSet Editor
2018-07-29 23:54:12 +02:00
edit_mode = EDITMODE_COLLISION;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
select_coord(Vector2(0, 0));
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_ICON]->hide();
tool_editmode[EDITMODE_BITMASK]->hide();
tool_editmode[EDITMODE_PRIORITY]->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
tool_editmode[EDITMODE_Z_INDEX]->hide();
Fixes for TileSetEditor and TileMapEditor [TileSetEditor] Hide Bitmask and Priority for ATLAS_TILE [TileMapEditor] Hide "Disable autotile" if the selected tile isn't autotile Fix #22756, don't update bitmask when tilemode is ATLAS_TILE
2018-12-20 18:17:52 +01:00
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (edit_mode == EDITMODE_ICON) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
select_coord(tileset->autotile_get_icon_coordinate(get_current_tile()));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
if (tool_editmode[EDITMODE_PRIORITY]->is_pressed() || tool_editmode[EDITMODE_BITMASK]->is_pressed()) {
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (edit_mode == EDITMODE_ICON) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
select_coord(tileset->autotile_get_icon_coordinate(get_current_tile()));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_editmode[EDITMODE_BITMASK]->hide();
}
_on_edit_mode_changed(edit_mode);
}
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
void TileSetEditor::update_workspace_minsize() {
Size2 workspace_min_size = get_current_texture()->get_size();
Use texture Path instead of RID to prevent name conflicts.
2020-05-01 16:39:40 +02:00
String current_texture_path = get_current_texture()->get_path();
List<int> tiles;
tileset->get_tile_list(&tiles);
for (List<int>::Element *E = tiles.front(); E; E = E->next()) {
if (tileset->tile_get_texture(E->get())->get_path() != current_texture_path) {
Fix TileSet editor's workspace size sometimes not changing correctly on region change
2020-01-10 04:57:49 +01:00
continue;
}
Rect2i region = tileset->tile_get_region(E->get());
if (region.position.x + region.size.x > workspace_min_size.x) {
workspace_min_size.x = region.position.x + region.size.x;
}
if (region.position.y + region.size.y > workspace_min_size.y) {
workspace_min_size.y = region.position.y + region.size.y;
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
}
}
Properly handle zoom when opening tileset editor
2019-11-12 16:23:30 +01:00
workspace_container->set_custom_minimum_size(workspace_min_size * workspace->get_scale() + WORKSPACE_MARGIN * 2);
workspace_overlay->set_custom_minimum_size(workspace_min_size * workspace->get_scale() + WORKSPACE_MARGIN * 2);
Fix TileSet editor workspace breaking
2021-11-17 17:35:16 +01:00
// Make sure workspace size is initialized last (otherwise it might be incorrect).
workspace->call_deferred("set_custom_minimum_size", workspace_min_size + WORKSPACE_MARGIN * 2);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::update_edited_region(const Vector2 &end_point) {
edited_region = Rect2(region_from, Size2());
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
Vector2 grid_coord;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
grid_coord = ((region_from - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 23:54:12 +02:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 16:36:51 +01:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(grid_coord);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
grid_coord = ((end_point - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 23:54:12 +02:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 16:36:51 +01:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(grid_coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(end_point);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
int TileSetEditor::get_current_tile() const {
return current_tile;
}
void TileSetEditor::set_current_tile(int p_id) {
if (current_tile != p_id) {
current_tile = p_id;
helper->_change_notify("");
select_coord(Vector2(0, 0));
update_workspace_tile_mode();
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (p_id == -1) {
editor->get_inspector()->edit(tileset.ptr());
} else {
editor->get_inspector()->edit(helper);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Ref<Texture> TileSetEditor::get_current_texture() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (texture_list->get_selected_items().size() == 0) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return Ref<Texture>();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
} else {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return texture_map[texture_list->get_item_metadata(texture_list->get_selected_items()[0])];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::set_tileset(const Ref<TileSet> &p_tileset) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset = p_tileset;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::set_snap_options_visible(bool p_visible) {
snap_options_visible = p_visible;
_change_notify("");
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool TilesetEditorContext::_set(const StringName &p_name, const Variant &p_value) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
String name = p_name.operator String();
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (name == "options_offset") {
Vector2 snap = p_value;
tileset_editor->_set_snap_off(snap + WORKSPACE_MARGIN);
return true;
} else if (name == "options_step") {
Vector2 snap = p_value;
tileset_editor->_set_snap_step(snap);
return true;
} else if (name == "options_separation") {
Vector2 snap = p_value;
tileset_editor->_set_snap_sep(snap);
return true;
} else if (p_name.operator String().left(5) == "tile_") {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
String name2 = p_name.operator String().right(5);
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool v = false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset_editor->get_current_tile() < 0 || tileset.is_null()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
if (name2 == "autotile_bitmask_mode") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/bitmask_mode", p_value, &v);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
} else if (name2 == "subtile_size") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/tile_size", p_value, &v);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
} else if (name2 == "subtile_spacing") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/spacing", p_value, &v);
} else {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/" + name2, p_value, &v);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (v) {
tileset->_change_notify("");
tileset_editor->workspace->update();
tileset_editor->workspace_overlay->update();
}
return v;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
} else if (name == "tileset_script") {
tileset->set_script(p_value);
return true;
TileSetEditor: Expose to the user OneWayCollision+Margin properties. Fixes #25817.
2019-03-04 04:22:10 +01:00
} else if (name == "selected_collision_one_way") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
tileset->tile_set_shape_one_way(tileset_editor->get_current_tile(), index, p_value);
return true;
}
}
return false;
} else if (name == "selected_collision_one_way_margin") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
tileset->tile_set_shape_one_way_margin(tileset_editor->get_current_tile(), index, p_value);
return true;
}
}
return false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_editor->err_dialog->set_text(TTR("This property can't be changed."));
tileset_editor->err_dialog->popup_centered(Size2(300, 60));
return false;
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool TilesetEditorContext::_get(const StringName &p_name, Variant &r_ret) const {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
String name = p_name.operator String();
Fix method not returning value in all paths (autotile editor)
2017-12-17 19:03:46 +01:00
bool v = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (name == "options_offset") {
r_ret = tileset_editor->snap_offset - WORKSPACE_MARGIN;
v = true;
} else if (name == "options_step") {
r_ret = tileset_editor->snap_step;
v = true;
} else if (name == "options_separation") {
r_ret = tileset_editor->snap_separation;
v = true;
} else if (name.left(5) == "tile_") {
name = name.right(5);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
if (tileset_editor->get_current_tile() < 0 || tileset.is_null()) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
if (!tileset->has_tile(tileset_editor->get_current_tile())) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 12:44:11 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (name == "autotile_bitmask_mode") {
r_ret = tileset->get(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/bitmask_mode", &v);
} else if (name == "subtile_size") {
r_ret = tileset->get(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/tile_size", &v);
} else if (name == "subtile_spacing") {
r_ret = tileset->get(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/spacing", &v);
} else {
r_ret = tileset->get(String::num(tileset_editor->get_current_tile(), 0) + "/" + name, &v);
}
return v;
} else if (name == "selected_collision") {
r_ret = tileset_editor->edited_collision_shape;
v = true;
TileSetEditor: Expose to the user OneWayCollision+Margin properties. Fixes #25817.
2019-03-04 04:22:10 +01:00
} else if (name == "selected_collision_one_way") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
r_ret = sd[index].one_way_collision;
v = true;
break;
}
}
} else if (name == "selected_collision_one_way_margin") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
r_ret = sd[index].one_way_collision_margin;
v = true;
break;
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (name == "selected_navigation") {
r_ret = tileset_editor->edited_navigation_shape;
v = true;
} else if (name == "selected_occlusion") {
r_ret = tileset_editor->edited_occlusion_shape;
v = true;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
} else if (name == "tileset_script") {
r_ret = tileset->get_script();
v = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fix method not returning value in all paths (autotile editor)
2017-12-17 19:03:46 +01:00
return v;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::_get_property_list(List<PropertyInfo> *p_list) const {
if (snap_options_visible) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Snap Options", "options_"), PROPERTY_HINT_NONE, "options_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_step")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("options_separation")));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (tileset_editor->get_current_tile() >= 0 && !tileset.is_null()) {
int id = tileset_editor->get_current_tile();
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Selected Tile", "tile_"), PROPERTY_HINT_NONE, "tile_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::STRING, PNAME("tile_name")));
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_texture"), PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_normal_map"), PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_tex_offset")));
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tile_material"), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial"));
p_list->push_back(PropertyInfo(Variant::COLOR, PNAME("tile_modulate")));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_tile_mode"), PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(id) == TileSet::AUTO_TILE) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_autotile_bitmask_mode"), PROPERTY_HINT_ENUM, "2x2,3x3 (minimal),3x3"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_subtile_size")));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_subtile_spacing"), PROPERTY_HINT_RANGE, "0, 1024, 1"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (tileset->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_subtile_size")));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_subtile_spacing"), PROPERTY_HINT_RANGE, "0, 1024, 1"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_occluder_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_navigation_offset")));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_shape_offset"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, PNAME("tile_shape_transform"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("tile_z_index"), PROPERTY_HINT_RANGE, itos(VS::CANVAS_ITEM_Z_MIN) + "," + itos(VS::CANVAS_ITEM_Z_MAX) + ",1"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_COLLISION && tileset_editor->edited_collision_shape.is_valid()) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_collision"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_collision_shape->get_class()));
TileSetEditor: Expose to the user OneWayCollision+Margin properties. Fixes #25817.
2019-03-04 04:22:10 +01:00
if (tileset_editor->edited_collision_shape.is_valid()) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::BOOL, PNAME("selected_collision_one_way"), PROPERTY_HINT_NONE));
p_list->push_back(PropertyInfo(Variant::REAL, PNAME("selected_collision_one_way_margin"), PROPERTY_HINT_NONE));
TileSetEditor: Expose to the user OneWayCollision+Margin properties. Fixes #25817.
2019-03-04 04:22:10 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_NAVIGATION && tileset_editor->edited_navigation_shape.is_valid()) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_navigation"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_navigation_shape->get_class()));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_OCCLUSION && tileset_editor->edited_occlusion_shape.is_valid()) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("selected_occlusion"), PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_occlusion_shape->get_class()));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
if (!tileset.is_null()) {
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NOEDITOR
2022-05-18 06:43:36 +02:00
p_list->push_back(PropertyInfo(Variant::OBJECT, PNAME("tileset_script"), PROPERTY_HINT_RESOURCE_TYPE, "Script"));
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Hide "Script" section in the "TilesetEditorContext"
2018-12-07 05:18:02 +01:00
void TilesetEditorContext::_bind_methods() {
Revert "Expose "meta" to the Inspector"
2019-07-22 12:03:57 +02:00
ClassDB::bind_method("_hide_script_from_inspector", &TilesetEditorContext::_hide_script_from_inspector);
Hide "Script" section in the "TilesetEditorContext"
2018-12-07 05:18:02 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
TilesetEditorContext::TilesetEditorContext(TileSetEditor *p_tileset_editor) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor = p_tileset_editor;
Added a workaround to avoid crashes due to how TileSet editor works, fixes #23672 Also fixed a few uninitialized memory variables.
2019-02-22 21:42:29 +01:00
snap_options_visible = false;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditorPlugin::edit(Object *p_node) {
if (Object::cast_to<TileSet>(p_node)) {
tileset_editor->edit(Object::cast_to<TileSet>(p_node));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
bool TileSetEditorPlugin::handles(Object *p_node) const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
return p_node->is_class("TileSet") || p_node->is_class("TilesetEditorContext");
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditorPlugin::make_visible(bool p_visible) {
if (p_visible) {
tileset_editor_button->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
editor->make_bottom_panel_item_visible(tileset_editor);
TileSet: Fix signal disconnect error in some situation Fixes second issue in #45938. Co-authored-by: kleonc <9283098+kleonc@users.noreply.github.com>
2021-05-10 15:07:14 +02:00
if (!get_tree()->is_connected("idle_frame", tileset_editor, "_on_workspace_process")) {
get_tree()->connect("idle_frame", tileset_editor, "_on_workspace_process");
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
editor->hide_bottom_panel();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor_button->hide();
TileSet: Fix signal disconnect error in some situation Fixes second issue in #45938. Co-authored-by: kleonc <9283098+kleonc@users.noreply.github.com>
2021-05-10 15:07:14 +02:00
if (get_tree()->is_connected("idle_frame", tileset_editor, "_on_workspace_process")) {
get_tree()->disconnect("idle_frame", tileset_editor, "_on_workspace_process");
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Dictionary TileSetEditorPlugin::get_state() const {
Dictionary state;
state["snap_offset"] = tileset_editor->snap_offset;
state["snap_step"] = tileset_editor->snap_step;
state["snap_separation"] = tileset_editor->snap_separation;
state["snap_enabled"] = tileset_editor->tools[TileSetEditor::TOOL_GRID_SNAP]->is_pressed();
state["keep_inside_tile"] = tileset_editor->tools[TileSetEditor::SHAPE_KEEP_INSIDE_TILE]->is_pressed();
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
state["show_information"] = tileset_editor->tools[TileSetEditor::VISIBLE_INFO]->is_pressed();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
return state;
}
void TileSetEditorPlugin::set_state(const Dictionary &p_state) {
Dictionary state = p_state;
if (state.has("snap_step")) {
tileset_editor->_set_snap_step(state["snap_step"]);
}
if (state.has("snap_offset")) {
tileset_editor->_set_snap_off(state["snap_offset"]);
}
if (state.has("snap_separation")) {
tileset_editor->_set_snap_sep(state["snap_separation"]);
}
if (state.has("snap_enabled")) {
tileset_editor->tools[TileSetEditor::TOOL_GRID_SNAP]->set_pressed(state["snap_enabled"]);
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (tileset_editor->helper) {
tileset_editor->_on_grid_snap_toggled(state["snap_enabled"]);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
if (state.has("keep_inside_tile")) {
tileset_editor->tools[TileSetEditor::SHAPE_KEEP_INSIDE_TILE]->set_pressed(state["keep_inside_tile"]);
}
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (state.has("show_information")) {
tileset_editor->tools[TileSetEditor::VISIBLE_INFO]->set_pressed(state["show_information"]);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
editor = p_node;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor = memnew(TileSetEditor(p_node));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
tileset_editor->hide();
Add option to move Tile/GridMap editors to another side
2018-08-21 06:35:48 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_editor_button = p_node->add_bottom_panel_item(TTR("TileSet"), tileset_editor);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor_button->hide();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Reference in a new issue Copy permalink