godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/editor/plugins/tile_set_editor_plugin.cpp

3615 lines
140 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 12:16:55 +00:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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-04 23:50:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 07:04:19 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
#include "core/os/input.h"
#include "core/os/keyboard.h"
Cleans up headers included in editor_node.h
2019-12-24 07:17:23 +00:00
#include "editor/editor_scale.h"
Implement auto-tiling
2017-10-22 01:42:23 +00:00
#include "editor/plugins/canvas_item_editor_plugin.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 15:44:50 +00: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 07:04:19 +00: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 15:44:50 +00:00
void TileSetEditor::edit(const Ref<TileSet> &p_tileset) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 15:44:50 +00:00
tileset = p_tileset;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset->add_change_receptor(this);
New TileSet Editor
2018-07-29 21:54:12 +00:00
texture_list->clear();
texture_map.clear();
update_texture_list();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 21:49:37 +00:00
void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 21:49:37 +00:00
for (int i = 0; i < p_node->get_child_count(); i++) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 21:49:37 +00:00
Node *child = p_node->get_child(i);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 20:58:51 +00: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 15:44:50 +00: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 21:49:37 +00:00
_import_node(child, p_library);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 21:49:37 +00: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 05:34:56 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 20:58:51 +00: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 15:44:50 +00:00
Ref<Texture> texture = mi->get_texture();
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 15:15:50 +00:00
Ref<Texture> normal_map = mi->get_normal_map();
New particle system, mostly working, some small features missing.
2017-04-07 02:36:37 +00: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 05:34:56 +00:00
if (texture.is_null())
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 05:34:56 +00: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 15:44:50 +00:00
if (id < 0) {
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 05:34:56 +00: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 15:44:50 +00:00
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 05:34:56 +00: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 15:44:50 +00: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 05:34:56 +00: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 15:44:50 +00:00
p_library->tile_set_texture(id, texture);
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 15:15:50 +00: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 15:44:50 +00: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 05:34:56 +00: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 15:44:50 +00:00
p_library->tile_set_modulate(id, mi->get_modulate());
Add modulate (color) to TileSet tiles
2016-11-30 13:33:39 +00: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 05:34:56 +00:00
Vector2 phys_offset;
Respect frame property when converting to TileSet.
2016-07-05 18:40:22 +00: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 05:34:56 +00: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 15:44:50 +00: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 18:40:22 +00: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 15:44:50 +00: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 18:40:22 +00: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 15:44:50 +00:00
Respect frame property when converting to TileSet.
2016-07-05 18:40:22 +00: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 15:44:50 +00: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 05:34:56 +00:00
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00: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 05:34:56 +00:00
Ref<NavigationPolygon> nav_poly;
Ref<OccluderPolygon2D> occluder;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00: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 05:34:56 +00: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 15:44:50 +00: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 05:34:56 +00:00
Node *child2 = mi->get_child(j);
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 20:58:51 +00:00
if (Object::cast_to<NavigationPolygonInstance>(child2))
nav_poly = Object::cast_to<NavigationPolygonInstance>(child2)->get_navigation_polygon();
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 05:34:56 +00: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 20:58:51 +00:00
if (Object::cast_to<LightOccluder2D>(child2))
occluder = Object::cast_to<LightOccluder2D>(child2)->get_occluder_polygon();
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 05:34:56 +00: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 20:58:51 +00: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 05:34:56 +00:00
continue;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00: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 20:58:51 +00: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 02:30:43 +00:00
List<uint32_t> shapes;
sb->get_shape_owners(&shapes);
for (List<uint32_t>::Element *E = shapes.front(); E; E = E->next()) {
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00:00
if (sb->is_shape_owner_disabled(E->get())) continue;
-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 02:30:43 +00:00
Fix bugs related to bad handling of rotated/translated shapes in tilemap Fixup #18529 and #12870
2018-06-03 13:32:23 +00: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 18:47:30 +00: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 13:32:23 +00:00
shape_transform[2] -= phys_offset;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00: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 02:30:43 +00: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 17:56:51 +00: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 22:13:46 +00:00
}
heck
2014-04-19 19:46:52 +00: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 05:34:56 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 17:56:51 +00: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 15:44:50 +00: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 10:58:07 +00:00
p_library->tile_set_z_index(id, mi->get_z_index());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
Updated function argument names
2017-08-12 16:52:50 +00:00
void TileSetEditor::_import_scene(Node *p_scene, Ref<TileSet> p_library, bool 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 21:49:37 +00:00
if (!p_merge)
p_library->clear();
Updated function argument names
2017-08-12 16:52:50 +00: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 21:49:37 +00:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 15:44:50 +00:00
Error TileSetEditor::update_library_file(Node *p_base_scene, Ref<TileSet> ml, bool p_merge) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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 15:44:50 +00:00
_import_scene(p_base_scene, ml, p_merge);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return OK;
}
Added drag and drop to the tileset plugin.
2019-08-26 09:15:19 +00: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;
if (!d.has("type"))
return false;
if (d.has("from") && (Object *)(d["from"]) == texture_list)
return false;
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"];
if (files.size() == 0)
return false;
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) {
if (!can_drop_data_fw(p_point, p_data, p_from))
return;
Dictionary d = p_data;
if (!d.has("type"))
return;
if (String(d["type"]) == "resource" && d.has("resource")) {
RES r = d["resource"];
Ref<Texture> texture = r;
if (texture.is_valid())
add_texture(texture);
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 01:10:30 +00:00
void TileSetEditor::_bind_methods() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
ClassDB::bind_method("_undo_redo_import_scene", &TileSetEditor::_undo_redo_import_scene);
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:08:44 +00:00
ClassDB::bind_method("_on_edit_mode_changed", &TileSetEditor::_on_edit_mode_changed);
New TileSet Editor
2018-07-29 21:54:12 +00:00
ClassDB::bind_method("_on_workspace_mode_changed", &TileSetEditor::_on_workspace_mode_changed);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
ClassDB::bind_method("_on_workspace_overlay_draw", &TileSetEditor::_on_workspace_overlay_draw);
New TileSet Editor
2018-07-29 21:54:12 +00:00
ClassDB::bind_method("_on_workspace_process", &TileSetEditor::_on_workspace_process);
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 13:39:39 +00:00
ClassDB::bind_method("_on_z_index_changed", &TileSetEditor::_on_z_index_changed);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
ClassDB::bind_method("_on_grid_snap_toggled", &TileSetEditor::_on_grid_snap_toggled);
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00: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 04:38:26 +00: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 16:20:49 +00: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-02-28 23:48:34 +00:00
ClassDB::bind_method("_sort_tiles", &TileSetEditor::_sort_tiles);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
Added drag and drop to the tileset plugin.
2019-08-26 09:15:19 +00: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 16:20:49 +00: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 01:09:11 +00:00
ClassDB::bind_method("update_workspace_minsize", &TileSetEditor::update_workspace_minsize);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_notification(int p_what) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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"));
tools[BITMASK_COPY]->set_icon(get_icon("Duplicate", "EditorIcons"));
tools[BITMASK_PASTE]->set_icon(get_icon("Override", "EditorIcons"));
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 11:27:53 +00: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-02-28 23:48:34 +00: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 04:38:26 +00: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 21:50:19 +00:00
_update_toggle_shape_button();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 13:39:39 +00:00
tool_editmode[EDITMODE_Z_INDEX]->set_icon(get_icon("Sort", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
scroll->add_style_override("bg", get_stylebox("bg", "Tree"));
} break;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
TileSetEditor::TileSetEditor(EditorNode *p_editor) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
editor = p_editor;
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
undo_redo = EditorNode::get_undo_redo();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
current_tile = -1;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
VBoxContainer *left_container = memnew(VBoxContainer);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
add_child(left_container);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 09:15:19 +00:00
texture_list->set_drag_forwarding(this);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
HBoxContainer *tileset_toolbar_container = memnew(HBoxContainer);
left_container->add_child(tileset_toolbar_container);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00: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 04:38:26 +00:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_tooltip(TTR("Add Texture(s) to TileSet."));
New TileSet Editor
2018-07-29 21:54:12 +00:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00: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 04:38:26 +00:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_tooltip(TTR("Remove selected Texture from TileSet."));
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
tileset_toolbar_tools->set_text(TTR("Tools"));
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
add_child(right_container);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
dragging_point = -1;
creating_shape = false;
Autotile Enhancement
2017-12-28 05:57:37 +00:00
snap_step = Vector2(32, 32);
New TileSet Editor
2018-07-29 21:54:12 +00:00
snap_offset = WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
set_custom_minimum_size(Size2(0, 150));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
VBoxContainer *main_vb = memnew(VBoxContainer);
New TileSet Editor
2018-07-29 21:54:12 +00:00
right_container->add_child(main_vb);
main_vb->set_v_size_flags(SIZE_EXPAND_FILL);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 06:57:15 +00: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 21:54:12 +00: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 06:57:15 +00:00
tool_workspacemode[i]->set_text(workspace_label[i]);
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
tool_workspacemode[i]->connect("pressed", this, "_on_workspace_mode_changed", varray(i));
New TileSet Editor
2018-07-29 21:54:12 +00: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-02-28 23:48:34 +00:00
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00: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 04:38:26 +00:00
tool_hb->move_child(spacer, WORKSPACE_CREATE_SINGLE);
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00: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 14:22:44 +00: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-02-28 23:48:34 +00: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 14:22:44 +00: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-02-28 23:48:34 +00: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 21:54:12 +00: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 06:57:15 +00: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 01:42:23 +00: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 04:38:26 +00:00
tool_editmode[i]->connect("pressed", this, "_on_edit_mode_changed", varray(i));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tool_hb->add_child(tool_editmode[i]);
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
add hotkeys to tileset editor
2019-04-13 05:45:57 +00: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 01:42:23 +00:00
main_vb->add_child(tool_hb);
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_editmode = memnew(HSeparator);
main_vb->add_child(separator_editmode);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
toolbar = memnew(HBoxContainer);
Ref<ButtonGroup> tg(memnew(ButtonGroup));
tools[TOOL_SELECT] = memnew(ToolButton);
New TileSet Editor
2018-07-29 21:54:12 +00:00
toolbar->add_child(tools[TOOL_SELECT]);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 04:38:26 +00:00
tools[TOOL_SELECT]->connect("pressed", this, "_on_tool_clicked", varray(TOOL_SELECT));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
separator_bitmask = memnew(VSeparator);
toolbar->add_child(separator_bitmask);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[BITMASK_COPY] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00:00
toolbar->add_child(tools[BITMASK_COPY]);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[BITMASK_PASTE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00:00
toolbar->add_child(tools[BITMASK_PASTE]);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[BITMASK_CLEAR] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00:00
toolbar->add_child(tools[BITMASK_CLEAR]);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 11:27:53 +00: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."));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[SHAPE_NEW_POLYGON] = memnew(ToolButton);
New TileSet Editor
2018-07-29 21:54:12 +00:00
toolbar->add_child(tools[SHAPE_NEW_POLYGON]);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 04:38:26 +00:00
tools[SHAPE_NEW_POLYGON]->set_tooltip(TTR("Create a new polygon."));
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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-12 23:24:20 +00:00
separator_delete = memnew(VSeparator);
toolbar->add_child(separator_delete);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[SHAPE_DELETE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
tools[SHAPE_DELETE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_DELETE));
New TileSet Editor
2018-07-29 21:54:12 +00:00
toolbar->add_child(tools[SHAPE_DELETE]);
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
Implement auto-tiling
2017-10-22 01:42:23 +00: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 13:39:39 +00: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 16:35:12 +00: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 01:42:23 +00: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 04:38:26 +00:00
tools[ZOOM_OUT]->connect("pressed", this, "_zoom_out");
Implement auto-tiling
2017-10-22 01:42:23 +00:00
toolbar->add_child(tools[ZOOM_OUT]);
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[ZOOM_OUT]->set_tooltip(TTR("Zoom Out"));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[ZOOM_1] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
tools[ZOOM_1]->connect("pressed", this, "_zoom_reset");
Implement auto-tiling
2017-10-22 01:42:23 +00:00
toolbar->add_child(tools[ZOOM_1]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
tools[ZOOM_1]->set_tooltip(TTR("Zoom Reset"));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
tools[ZOOM_IN] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
tools[ZOOM_IN]->connect("pressed", this, "_zoom_in");
Implement auto-tiling
2017-10-22 01:42:23 +00:00
toolbar->add_child(tools[ZOOM_IN]);
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
tools[VISIBLE_INFO]->set_tooltip(TTR("Display Tile Names (Hold Alt Key)"));
New TileSet Editor
2018-07-29 21:54:12 +00:00
toolbar->add_child(tools[VISIBLE_INFO]);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
main_vb->add_child(toolbar);
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
scroll = memnew(ScrollContainer);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
main_vb->add_child(scroll);
scroll->set_v_size_flags(SIZE_EXPAND_FILL);
New TileSet Editor
2018-07-29 21:54:12 +00:00
scroll->set_clip_contents(true);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Add informational messages to various editors
2019-09-04 05:20:57 +00: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 09:12:15 +00:00
empty_message->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
Add informational messages to various editors
2019-09-04 05:20:57 +00:00
empty_message->set_v_size_flags(SIZE_EXPAND_FILL);
main_vb->add_child(empty_message);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
workspace_container = memnew(Control);
scroll->add_child(workspace_container);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00: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 01:42:23 +00:00
workspace = memnew(Control);
New TileSet Editor
2018-07-29 21:54:12 +00:00
workspace->set_focus_mode(FOCUS_ALL);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 11:36:18 +00:00
workspace->set_draw_behind_parent(true);
workspace_overlay->add_child(workspace);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
preview = memnew(Sprite);
workspace->add_child(preview);
preview->set_centered(false);
preview->set_draw_behind_parent(true);
New TileSet Editor
2018-07-29 21:54:12 +00:00
preview->set_position(WORKSPACE_MARGIN);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
//---------------
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
cd = memnew(ConfirmationDialog);
add_child(cd);
New TileSet Editor
2018-07-29 21:54:12 +00:00
cd->connect("confirmed", this, "_on_tileset_toolbar_confirm");
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
//---------------
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
err_dialog = memnew(AcceptDialog);
add_child(err_dialog);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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()) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
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 16:35:12 +00: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 13:56:05 +00:00
Add informational messages to various editors
2019-09-04 05:20:57 +00: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 19:48:47 +00: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 13:56:05 +00:00
scale_ratio = 1.2f;
fix updating tileset list when assign texture and set autotile true
2018-01-10 22:45:14 +00:00
}
TileSetEditorPlgn: Fix a leak
2018-02-27 02:54:09 +00:00
TileSetEditor::~TileSetEditor() {
if (helper)
memdelete(helper);
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
cd->set_text(TTR("Remove selected texture? This will remove all tiles which use it."));
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
cd->set_text(TTR("Create from scene? This will overwrite all current tiles."));
New TileSet Editor
2018-07-29 21:54:12 +00: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: {
RID current_rid = get_current_texture()->get_rid();
List<int> ids;
tileset->get_tile_list(&ids);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
undo_redo->create_action(TTR("Remove Texture"));
New TileSet Editor
2018-07-29 21:54:12 +00:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
if (tileset->tile_get_texture(E->get())->get_rid() == current_rid) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
undo_redo->add_do_method(tileset.ptr(), "remove_tile", E->get());
_undo_tile_removal(E->get());
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00:00
} break;
case TOOL_TILESET_MERGE_SCENE:
case TOOL_TILESET_CREATE_SCENE: {
EditorNode *en = editor;
Node *scene = en->get_edited_scene();
if (!scene)
break;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00:00
} break;
}
}
void TileSetEditor::_on_texture_list_selected(int p_index) {
if (get_current_texture().is_valid()) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
current_item_index = p_index;
New TileSet Editor
2018-07-29 21:54:12 +00:00
preview->set_texture(get_current_texture());
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
update_workspace_tile_mode();
Make TileSet editor's workspace change size according to region changes
2019-02-28 01:09:11 +00:00
update_workspace_minsize();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} else {
current_item_index = -1;
preview->set_texture(NULL);
workspace->set_custom_minimum_size(Size2i());
New TileSet Editor
2018-07-29 21:54:12 +00:00
update_workspace_tile_mode();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Make TileSet editor's workspace change size according to region changes
2019-02-28 01:09:11 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
set_current_tile(-1);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
workspace->update();
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 15:13:44 +00: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 02:57:49 +00: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 15:13:44 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (texture_map.has(t->get_rid())) {
invalid_count++;
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
add_texture(t);
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
TileSetEditor: Don't crash when adding invalid files
2018-10-11 15:13:44 +00: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 21:54:12 +00:00
if (invalid_count > 0) {
Fix vformat(), minor typos and word puzzles
2018-08-28 18:15:04 +00: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 21:54:12 +00:00
err_dialog->popup_centered(Size2(300, 60));
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_edit_mode_changed(int p_edit_mode) {
Fixes editor crashing when editing autotiles issue #24004
2018-12-06 09:35:38 +00:00
draw_handles = false;
creating_shape = false;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
edit_mode = (EditMode)p_edit_mode;
switch (edit_mode) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
case EDITMODE_REGION: {
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:27:53 +00:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
if (workspace_mode == WORKSPACE_EDIT) {
separator_delete->show();
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
} else {
separator_delete->hide();
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
}
separator_grid->show();
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete selected Rect."));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
spin_z_index->hide();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} break;
case EDITMODE_COLLISION:
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:27:53 +00:00
tools[SHAPE_NEW_RECTANGLE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_delete->show();
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_grid->show();
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete polygon."));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
spin_z_index->hide();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} break;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 11:27:53 +00:00
tools[SHAPE_NEW_RECTANGLE]->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 17:28:42 +00: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 04:38:26 +00:00
spin_priority->hide();
} break;
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
case EDITMODE_Z_INDEX:
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
case EDITMODE_PRIORITY:
case EDITMODE_ICON: {
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:27:53 +00:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_delete->hide();
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_grid->show();
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_GRID_SNAP]->show();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
Implement auto-tiling
2017-10-22 01:42:23 +00:00
if (edit_mode == EDITMODE_ICON) {
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
spin_z_index->hide();
} else if (edit_mode == EDITMODE_PRIORITY) {
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
spin_priority->show();
Add Z-Index for Autotile
2018-07-02 13:39:39 +00: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 01:42:23 +00: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 15:08:36 +00:00
default: {
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
_update_toggle_shape_button();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
workspace->update();
}
New TileSet Editor
2018-07-29 21:54:12 +00: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-12 23:24:20 +00:00
separator_editmode->show();
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_workspace_draw() {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (tileset.is_null() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 21:54:12 +00:00
return;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 21:54:12 +00:00
draw_highlight_current_tile();
draw_grid_snap();
if (get_current_tile() >= 0) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
switch (edit_mode) {
case EDITMODE_ICON: {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Vector2 coord = tileset->autotile_get_icon_coordinate(get_current_tile());
New TileSet Editor
2018-07-29 21:54:12 +00:00
draw_highlight_subtile(coord);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} break;
case EDITMODE_BITMASK: {
New TileSet Editor
2018-07-29 21:54:12 +00: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 17:28:42 +00:00
Color ci(0.3, 0.6, 1, 0.5);
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00: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 01:42:23 +00:00
Vector2 coord(x, y);
Point2 anchor(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 21:54:12 +00: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 17:28:42 +00:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00:00
workspace->draw_rect(Rect2(anchor + size / 2, size / 2), c);
}
Restore support for minimal 3x3 autotile sets
2018-05-17 03:39:43 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00: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 21:54:12 +00: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 08:11:05 +00:00
draw_highlight_subtile(edited_shape_coord);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
draw_polygon_shapes();
Autotile Enhancement
2017-12-28 05:57:37 +00:00
draw_grid_snap();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} break;
case EDITMODE_PRIORITY: {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 17:28:42 +00:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), edited_shape_coord);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 17:28:42 +00: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 01:42:23 +00:00
if (E->value() == mask) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
total += tileset->autotile_get_subtile_priority(get_current_tile(), E->key());
Implement auto-tiling
2017-10-22 01:42:23 +00: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 21:54:12 +00:00
draw_highlight_subtile(edited_shape_coord, queue_others);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} break;
Add Z-Index for Autotile
2018-07-02 13:39:39 +00: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 15:08:36 +00:00
default: {
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
RID current_texture_rid = get_current_texture()->get_rid();
List<int> *tiles = new List<int>();
tileset->get_tile_list(tiles);
for (List<int>::Element *E = tiles->front(); E; E = E->next()) {
int t_id = E->get();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (tileset->tile_get_texture(t_id)->get_rid() == current_texture_rid && (t_id != get_current_tile() || edit_mode != EDITMODE_REGION || workspace_mode != WORKSPACE_EDIT)) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
Rect2i region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
Color c;
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE)
c = COLOR_SINGLE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE)
c = COLOR_AUTOTILE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE)
c = COLOR_ATLAS;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
New TileSet Editor
2018-07-29 21:54:12 +00:00
workspace->draw_rect(region, c, false);
}
}
Fix memory leak in Tilemaps
2019-06-28 13:37:09 +00:00
delete tiles;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (edit_mode == EDITMODE_REGION) {
if (workspace_mode != WORKSPACE_EDIT) {
Rect2i region = edited_region;
Color c;
if (workspace_mode == WORKSPACE_CREATE_SINGLE)
c = COLOR_SINGLE;
else if (workspace_mode == WORKSPACE_CREATE_AUTOTILE)
c = COLOR_AUTOTILE;
else if (workspace_mode == WORKSPACE_CREATE_ATLAS)
c = COLOR_ATLAS;
workspace->draw_rect(region, c, false);
draw_edited_region_subdivision();
} else {
int t_id = get_current_tile();
Fix small drawing error in TileSet editor
2018-12-20 21:52:56 +00:00
if (t_id < 0)
return;
New TileSet Editor
2018-07-29 21:54:12 +00:00
Rect2i region;
if (draw_edited_region)
region = edited_region;
else {
region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (draw_edited_region)
draw_edited_region_subdivision();
else
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
New TileSet Editor
2018-07-29 21:54:12 +00:00
Color c;
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE)
c = COLOR_SINGLE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE)
c = COLOR_AUTOTILE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE)
c = COLOR_ATLAS;
workspace->draw_rect(region, c, false);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
workspace_overlay->update();
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::_on_workspace_process() {
General fixes for the TileSet editor
2018-12-24 16:35:12 +00: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 21:54:12 +00:00
workspace_overlay->update();
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
void TileSetEditor::_on_workspace_overlay_draw() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (!tileset.is_valid() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 21:54:12 +00:00
return;
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 16:35:12 +00:00
if (tile_names_visible) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
RID current_texture_rid = get_current_texture()->get_rid();
List<int> *tiles = new List<int>();
tileset->get_tile_list(tiles);
for (List<int>::Element *E = tiles->front(); E; E = E->next()) {
int t_id = E->get();
Fix position of tile names in TileSet editor when zooming in/out Fixes #27713.
2019-04-11 22:01:18 +00:00
if (tileset->tile_get_texture(t_id)->get_rid() != current_texture_rid)
continue;
Rect2 region = tileset->tile_get_region(t_id);
region.position += WORKSPACE_MARGIN;
region.position *= workspace->get_scale().x;
Color c;
if (tileset->tile_get_tile_mode(t_id) == TileSet::SINGLE_TILE)
c = COLOR_SINGLE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::AUTO_TILE)
c = COLOR_AUTOTILE;
else if (tileset->tile_get_tile_mode(t_id) == TileSet::ATLAS_TILE)
c = COLOR_ATLAS;
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 21:54:12 +00:00
}
Fix memory leak in Tilemaps
2019-06-28 13:37:09 +00:00
delete tiles;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
int t_id = get_current_tile();
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (t_id < 0)
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
return;
Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:36:18 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00: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 20:35:23 +00: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;
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (tileset.is_null() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 21:54:12 +00:00
return;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 17:28:42 +00:00
static bool alternative;
New TileSet Editor
2018-07-29 21:54:12 +00:00
draw_edited_region = false;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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;
Ref<InputEventMouseButton> mb = p_ie;
Ref<InputEventMouseMotion> mm = p_ie;
if (mb.is_valid()) {
fix tile set editor crash when drawing polygon shapes
2018-11-07 18:10:13 +00:00
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && !creating_shape) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (!current_tile_region.has_point(mb->get_position())) {
List<int> *tiles = new List<int>();
tileset->get_tile_list(tiles);
for (List<int>::Element *E = tiles->front(); E; E = E->next()) {
int t_id = E->get();
if (get_current_texture()->get_rid() == tileset->tile_get_texture(t_id)->get_rid()) {
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();
Fix memory leak in Tilemaps
2019-06-28 13:37:09 +00:00
delete tiles;
New TileSet Editor
2018-07-29 21:54:12 +00:00
return;
}
}
}
Fix memory leak in Tilemaps
2019-06-28 13:37:09 +00:00
delete tiles;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 13:56:05 +00:00
// Mouse Wheel Event
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed() && mb->get_control()) {
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 13:56:05 +00:00
_zoom_in();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
} else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed() && mb->get_control()) {
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 13:56:05 +00:00
_zoom_out();
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
// 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 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00: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 01:09:11 +00: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 03:57:49 +00: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 01:09:11 +00: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 03:57:49 +00: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 01:09:11 +00: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 03:57:49 +00: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 01:09:11 +00: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 16:20:49 +00:00
edited_region = Rect2();
Make TileSet editor's workspace change size according to region changes
2019-02-28 01:09:11 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00:00
} else {
int t_id = tileset->get_last_unused_tile_id();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00:00
if (workspace_mode != WORKSPACE_CREATE_SINGLE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 01:09:11 +00: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 16:20:49 +00: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 21:54:12 +00:00
_on_workspace_mode_changed(WORKSPACE_EDIT);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
} else {
edited_region = Rect2();
workspace->update();
workspace_overlay->update();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
if (workspace_mode == WORKSPACE_EDIT) {
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00: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 21:54:12 +00: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 17:28:42 +00:00
alternative = Input::get_singleton()->is_key_pressed(KEY_SHIFT);
New TileSet Editor
2018-07-29 21:54:12 +00: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 17:28:42 +00:00
uint32_t bit = 0;
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00: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 17:28:42 +00: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 16:20:49 +00: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 17:28:42 +00:00
new_mask |= (bit << 16);
} else if (erasing) {
new_mask &= ~bit;
new_mask &= ~(bit << 16);
New TileSet Editor
2018-07-29 21:54:12 +00:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 17:28:42 +00:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 17:28:42 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 21:54:12 +00: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 17:28:42 +00:00
alternative = false;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 21:54:12 +00: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 17:28:42 +00:00
uint32_t bit = 0;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
Implement auto-tiling
2017-10-22 01:42:23 +00: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 03:39:43 +00:00
} else {
Implement auto-tiling
2017-10-22 01:42:23 +00: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 16:20:49 +00: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 17:28:42 +00: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 16:20:49 +00: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 17:28:42 +00:00
new_mask &= ~(bit << 16);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 17:28:42 +00:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
}
}
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
} break;
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00: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 20:35:23 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
const real_t grab_threshold = EDITOR_GET("editors/poly_editor/point_grab_radius");
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:35:23 +00: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 01:42:23 +00:00
}
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
Vector<Vector2> points;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 05:57:37 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
undo_redo->create_action(TTR("Edit Collision Polygon"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
_set_edited_shape_points(points);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
if (dragging_point >= 0) {
dragging_point = -1;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
PoolVector<Vector2> polygon;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
}
Implement auto-tiling
2017-10-22 01:42:23 +00: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 17:08:43 +00:00
w.release();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00: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 17:08:43 +00:00
w.release();
fix crash autotile edit mode
2018-02-16 10:48:01 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
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());
Fix Redundant Navigation Polygons When adjusting the vertices of a navigation polygon, the tile editor would create a duplicate navigation polygon. So each time you made an adjustment, another copy of the polygon would be created.
2019-08-04 23:09:57 +00:00
undo_redo->add_do_method(edited_navigation_shape.ptr(), "clear_polygons");
undo_redo->add_undo_method(edited_navigation_shape.ptr(), "clear_polygons");
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
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 01:42:23 +00:00
}
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
workspace->update();
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:35:23 +00: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 05:34:33 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 21:50:19 +00:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>());
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
workspace->update();
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
} else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (creating_shape) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
creating_shape = false;
_select_edited_shape_coord();
workspace->update();
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
} else if (mm.is_valid()) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
if (creating_shape) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
workspace->update();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 11:27:53 +00: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 21:50:19 +00: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 11:27:53 +00:00
current_shape.resize(0);
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 20:35:00 +00: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 11:27:53 +00:00
workspace->update();
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 20:35:00 +00: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 11:27:53 +00: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 20:35:00 +00: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 20:35:23 +00: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 20:35:00 +00: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 20:35:23 +00:00
Tileset-Editor: Added alternative tool for drawing a rectangular shape.
2019-04-18 20:35:00 +00: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 11:27:53 +00:00
workspace->update();
}
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 15:08:36 +00:00
default: {
}
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
}
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_tool_clicked(int p_tool) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
if (p_tool == BITMASK_COPY) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
bitmask_map_copy = tileset->autotile_get_bitmask_map(get_current_tile());
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} else if (p_tool == BITMASK_PASTE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 17:28:42 +00: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 16:20:49 +00:00
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
Implement auto-tiling
2017-10-22 01:42:23 +00: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 17:28:42 +00: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 16:20:49 +00: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 01:42:23 +00:00
} else if (p_tool == BITMASK_CLEAR) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 17:28:42 +00: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 16:20:49 +00: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 21:50:19 +00: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()) {
// Make concave
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()) {
// Make convex
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);
sd.insert(i, edited_collision_shape);
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();
break;
}
}
_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-02-28 23:48:34 +00:00
} else if (p_tool == SELECT_NEXT) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
_select_next_shape();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
} else if (p_tool == SELECT_PREVIOUS) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
_select_previous_shape();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
} else if (p_tool == SHAPE_DELETE) {
TileMap Fixes
2017-12-01 00:50:09 +00:00
if (creating_shape) {
creating_shape = false;
current_shape.resize(0);
workspace->update();
} else {
switch (edit_mode) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
case EDITMODE_REGION: {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:09:11 +00: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 16:20:49 +00: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 21:54:12 +00:00
}
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
update_workspace_tile_mode();
} break;
TileMap Fixes
2017-12-01 00:50:09 +00:00
case EDITMODE_COLLISION: {
if (!edited_collision_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 00:50:09 +00:00
for (int i = 0; i < sd.size(); i++) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 00:50:09 +00:00
break;
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 00:50:09 +00:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 00:50:09 +00:00
}
} break;
case EDITMODE_NAVIGATION: {
if (!edited_navigation_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 00:50:09 +00: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 15:08:36 +00:00
default: {
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
} else if (p_tool == TOOL_SELECT) {
if (creating_shape) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
// Cancel Creation
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
creating_shape = false;
current_shape.resize(0);
workspace->update();
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_priority_changed(float val) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if ((int)val == tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord))
return;
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 01:42:23 +00:00
}
Add Z-Index for Autotile
2018-07-02 13:39:39 +00:00
void TileSetEditor::_on_z_index_changed(float val) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if ((int)val == tileset->autotile_get_z_index(get_current_tile(), edited_shape_coord))
return;
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 13:39:39 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::_on_grid_snap_toggled(bool p_val) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
helper->set_snap_options_visible(p_val);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
workspace->update();
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 09:54:12 +00: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 21:50:19 +00: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());
} else if (concave.is_valid()) {
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]);
concave->set_segments(segments);
undo_redo->add_do_method(concave.ptr(), "set_segments", segments);
undo_redo->add_undo_method(concave.ptr(), "set_segments", concave->get_segments());
} else {
// Invalid shape
}
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
void TileSetEditor::_update_tile_data() {
current_tile_data.clear();
if (get_current_tile() < 0)
return;
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 {
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 08:11:05 +00:00
Vector2 cell_count = (size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing))).floor();
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 21:50:19 +00: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 02:31:55 +00:00
tools[SHAPE_TOGGLE_TYPE]->set_text(TTR("Make Convex"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 02:31:55 +00:00
tools[SHAPE_TOGGLE_TYPE]->set_text(TTR("Make Concave"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 10:34:40 +00:00
// Shouldn't happen
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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-02-28 23:48:34 +00: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 15:08:36 +00:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00: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: {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 08:11:05 +00:00
Vector2 cell_count = (size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing))).floor();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
cell_count -= Vector2(1, 1);
edited_shape_coord = cell_count;
_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 15:08:36 +00:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00: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 13:08:25 +00: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-02-28 23:48:34 +00:00
} else {
return false;
}
}
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 {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 08:11:05 +00:00
Vector2 cell_count = (size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing))).floor();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
if (edited_shape_coord.x >= cell_count.x - 1 && edited_shape_coord.y >= cell_count.y - 1) {
_select_next_tile();
} else {
edited_shape_coord.x++;
if (edited_shape_coord.x >= cell_count.x) {
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 {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Some Vector2i usage cleanup Replace casting Vector2 -> Vector2i -> Vector2 with a simple call to .floor(), and some minor fixes.
2019-08-03 08:11:05 +00:00
Vector2 cell_count = (size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing))).floor();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-02-28 23:48:34 +00:00
if (edited_shape_coord.x <= 0 && edited_shape_coord.y <= 0) {
_select_previous_tile();
} else {
edited_shape_coord.x--;
if (edited_shape_coord.x == -1) {
edited_shape_coord.x = cell_count.x - 1;
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 01:45:16 +00: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 08:11:05 +00:00
Vector2i edited_coord = Vector2i();
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 08:11:05 +00:00
edited_coord = Vector2i(edited_shape_coord);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 08:11:05 +00:00
Vector2i edited_coord = Vector2i();
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 08:11:05 +00:00
edited_coord = Vector2i(edited_shape_coord);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00:00
}
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 01:45:16 +00:00
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 01:45:16 +00: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 21:50:19 +00: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 01:45:16 +00:00
}
}
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 21:54:12 +00:00
void TileSetEditor::_set_snap_step(Vector2 p_val) {
snap_step.x = CLAMP(p_val.x, 0, 256);
snap_step.y = CLAMP(p_val.y, 0, 256);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
workspace->update();
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::_set_snap_off(Vector2 p_val) {
snap_offset.x = CLAMP(p_val.x, 0, 256 + WORKSPACE_MARGIN.x);
snap_offset.y = CLAMP(p_val.y, 0, 256 + WORKSPACE_MARGIN.y);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
workspace->update();
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::_set_snap_sep(Vector2 p_val) {
snap_separation.x = CLAMP(p_val.x, 0, 256);
snap_separation.y = CLAMP(p_val.y, 0, 256);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
workspace->update();
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
void TileSetEditor::_validate_current_tile_id() {
if (get_current_tile() >= 0 && !tileset->has_tile(get_current_tile()))
set_current_tile(-1);
}
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 {
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()) {
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", p_id, E->value(), E->key());
}
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()) {
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 17:28:42 +00: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 16:20:49 +00: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 13:56:05 +00:00
void TileSetEditor::_zoom_in() {
float scale = workspace->get_scale().x;
if (scale < max_scale) {
scale *= scale_ratio;
workspace->set_scale(Vector2(scale, scale));
workspace_container->set_custom_minimum_size(workspace->get_rect().size * scale);
workspace_overlay->set_custom_minimum_size(workspace->get_rect().size * scale);
}
}
void TileSetEditor::_zoom_out() {
float scale = workspace->get_scale().x;
if (scale > min_scale) {
scale /= scale_ratio;
workspace->set_scale(Vector2(scale, scale));
workspace_container->set_custom_minimum_size(workspace->get_rect().size * scale);
workspace_overlay->set_custom_minimum_size(workspace->get_rect().size * scale);
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 13:56:05 +00: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);
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::draw_highlight_current_tile() {
Autotile Enhancement
2017-12-28 05:57:37 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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;
}
if (region.position.y >= 0)
workspace->draw_rect(Rect2(0, 0, workspace->get_rect().size.x, region.position.y), shadow_color);
if (region.position.x >= 0)
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);
if (region.position.x + region.size.x <= workspace->get_rect().size.x)
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);
if (region.position.y + region.size.y <= workspace->get_rect().size.y)
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);
New TileSet Editor
2018-07-29 21:54:12 +00:00
} else {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
workspace->draw_rect(Rect2(Point2(0, 0), workspace->get_rect().size), shadow_color);
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
Autotile Enhancement
2017-12-28 05:57:37 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::draw_highlight_subtile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Color shadow_color = Color(0.3, 0.3, 0.3, 0.3);
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 21:54:12 +00:00
coord += region.position;
coord += WORKSPACE_MARGIN;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
if (coord.y >= 0)
workspace->draw_rect(Rect2(0, 0, workspace->get_rect().size.x, coord.y), shadow_color);
if (coord.x >= 0)
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);
if (coord.x + size.x <= workspace->get_rect().size.x)
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);
if (coord.y + size.y <= workspace->get_rect().size.y)
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);
TileSetEditorPlugin: take scale in accout when highlighting current selected subtile.
2018-01-18 00:07:43 +00: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 01:42:23 +00: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 21:54:12 +00:00
coord += region.position;
coord += WORKSPACE_MARGIN;
TileSetEditorPlugin: take scale in accout when highlighting current selected subtile.
2018-01-18 00:07:43 +00:00
coord += Vector2(1, 1) / workspace->get_scale().x;
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
float j = size.x;
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
j = size.y;
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
}
void TileSetEditor::draw_edited_region_subdivision() const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Color c = Color(0.3, 0.7, 0.6);
New TileSet Editor
2018-07-29 21:54:12 +00:00
Rect2 region = edited_region;
Size2 size;
int spacing;
bool draw;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
if (draw) {
float j = size.x;
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
j = size.y;
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::draw_grid_snap() {
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Color grid_color = Color(0.4, 0, 1);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
Size2 s = workspace->get_size();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 05:57:37 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
int last_p = 0;
Autotile Enhancement
2017-12-28 05:57:37 +00: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 04:38:26 +00: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 05:57:37 +00: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 04:38:26 +00:00
}
Autotile Enhancement
2017-12-28 05:57:37 +00:00
last_p += snap_step.x;
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
last_p = 0;
Autotile Enhancement
2017-12-28 05:57:37 +00: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-07 23:29:35 +00:00
if (snap_separation.y != 0) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 05:57:37 +00: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 04:38:26 +00:00
}
Autotile Enhancement
2017-12-28 05:57:37 +00:00
last_p += snap_step.y;
}
}
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::draw_polygon_shapes() {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
int t_id = get_current_tile();
if (t_id < 0)
return;
switch (edit_mode) {
case EDITMODE_COLLISION: {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(t_id);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
for (int i = 0; i < sd.size(); i++) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Vector2 coord = Vector2(0, 0);
Vector2 anchor = Vector2(0, 0);
New TileSet Editor
2018-07-29 21:54:12 +00: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 11:08:44 +00: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 21:54:12 +00: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 21:50:19 +00:00
Ref<Shape2D> shape = sd[i].shape;
Implement auto-tiling
2017-10-22 01:42:23 +00: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 21:50:19 +00:00
Ref<ConvexPolygonShape2D> convex = shape;
bool is_convex = convex.is_valid();
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 21:50:19 +00: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 01:42:23 +00:00
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00: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 01:42:23 +00:00
}
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape && shape == edited_collision_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 01:42:23 +00: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 21:50:19 +00: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 01:42:23 +00:00
colors.push_back(c_bg);
}
}
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 14:45:18 +00:00
if (polygon.size() < 3)
Update tile_set_editor_plugin.cpp
2019-03-27 17:20:52 +00:00
continue;
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 14:45:18 +00:00
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (coord == edited_shape_coord || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape) {
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 01:42:23 +00:00
}
if (shape == edited_collision_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
}
}
} break;
case EDITMODE_OCCLUSION: {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 20:10:01 +00: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 16:20:49 +00:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 16:35:12 +00: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 11:08:44 +00:00
}
workspace->draw_polygon(polygon, colors);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape) {
TileSetEditor: Don't draw invalid occlusion shapes. Fixes #24238
2019-03-06 18:31:16 +00:00
if (polygon.size() > 1) {
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);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
} else {
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()) {
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 21:54:12 +00:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
for (int j = 0; j < current_shape.size(); j++) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 16:35:12 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (coord == edited_shape_coord) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape) {
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 11:08:44 +00:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 11:36:18 +00:00
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
}
}
}
} break;
case EDITMODE_NAVIGATION: {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 01:42:23 +00: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 20:10:01 +00: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 16:20:49 +00:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
PoolVector<Vector2> vertices = shape->get_vertices();
for (int j = 0; j < shape->get_polygon(0).size(); j++) {
polygon.push_back(vertices[shape->get_polygon(0)[j]] + anchor);
colors.push_back(c_bg);
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
workspace->draw_polygon(polygon, colors);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape) {
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 16:35:12 +00:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
} else {
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()) {
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 21:54:12 +00:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 16:20:49 +00:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 16:35:12 +00:00
} else {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
PoolVector<Vector2> vertices = shape->get_vertices();
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
for (int j = 0; j < shape->get_polygon(0).size(); j++) {
polygon.push_back(vertices[shape->get_polygon(0)[j]] + anchor);
colors.push_back(c_bg);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (coord == edited_shape_coord) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (!creating_shape) {
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 16:35:12 +00:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00: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 15:08:36 +00:00
default: {
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
General fixes for the TileSet editor
2018-12-24 16:35:12 +00:00
Implement auto-tiling
2017-10-22 01:42:23 +00:00
if (creating_shape) {
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 16:20:49 +00:00
draw_handles = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
void TileSetEditor::close_shape(const Vector2 &shape_anchor) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
creating_shape = false;
if (edit_mode == EDITMODE_COLLISION) {
Autotile Enhancement
2017-12-28 05:57:37 +00:00
if (current_shape.size() >= 3) {
Ref<ConvexPolygonShape2D> shape = memnew(ConvexPolygonShape2D);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
Vector<Vector2> points;
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
float p_total = 0;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Autotile Enhancement
2017-12-28 05:57:37 +00:00
for (int i = 0; i < current_shape.size(); i++) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
points.push_back(current_shape[i] - shape_anchor);
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
if (i != current_shape.size() - 1)
p_total += ((current_shape[i + 1].x - current_shape[i].x) * (-current_shape[i + 1].y + (-current_shape[i].y)));
else
p_total += ((current_shape[0].x - current_shape[i].x) * (-current_shape[0].y + (-current_shape[i].y)));
Autotile Enhancement
2017-12-28 05:57:37 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
if (p_total < 0)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
points.invert();
Improve : ease of use TileSet Editor
2017-12-30 05:34:33 +00:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
shape->set_points(points);
Autotile Enhancement
2017-12-28 05:57:37 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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);
New TileSet Editor
2018-07-29 21:54:12 +00: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 16:20:49 +00:00
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
else
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), shape, Transform2D());
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 05:57:37 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00: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 17:08:43 +00:00
w.release();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
shape->set_polygon(polygon);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00: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 17:08:43 +00:00
w.release();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
shape->set_vertices(polygon);
shape->add_polygon(indices);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset->_change_notify("");
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:45:16 +00:00
_update_tile_data();
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
current_shape = PoolVector2Array();
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 20:10:01 +00:00
if (get_current_tile() == -1)
return;
New TileSet Editor
2018-07-29 21:54:12 +00:00
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
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 21:50:19 +00:00
_set_edited_collision_shape(tileset->tile_get_shape(get_current_tile(), 0));
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (edited_occlusion_shape != tileset->tile_get_light_occluder(get_current_tile()))
edited_occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
if (edited_navigation_shape != tileset->tile_get_navigation_polygon(get_current_tile()))
edited_navigation_shape = tileset->tile_get_navigation_polygon(get_current_tile());
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 21:50:19 +00: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 11:08:44 +00:00
}
Fixing weird behaviour on autotile editor
2018-01-05 10:53:30 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 21:54:12 +00:00
current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
}
} else if (edit_mode == EDITMODE_NAVIGATION) {
current_shape.resize(0);
if (edited_navigation_shape.is_valid()) {
if (edited_navigation_shape->get_polygon_count() > 0) {
PoolVector<Vector2> vertices = edited_navigation_shape->get_vertices();
for (int i = 0; i < edited_navigation_shape->get_polygon(0).size(); i++) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
}
Fixing weird behaviour on autotile editor
2018-01-05 10:53:30 +00:00
}
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00: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) {
if (edited_collision_shape != sd[i].shape)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
_set_edited_collision_shape(sd[i].shape);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
found_collision_shape = true;
break;
}
}
if (!found_collision_shape)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 21:50:19 +00:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>(NULL));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
if (edited_occlusion_shape != tileset->autotile_get_light_occluder(get_current_tile(), coord))
edited_occlusion_shape = tileset->autotile_get_light_occluder(get_current_tile(), coord);
if (edited_navigation_shape != tileset->autotile_get_navigation_polygon(get_current_tile(), coord))
edited_navigation_shape = tileset->autotile_get_navigation_polygon(get_current_tile(), coord);
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 21:54:12 +00:00
shape_anchor += current_tile_region.position;
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 21:50:19 +00: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 11:08:44 +00: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()) {
if (edited_navigation_shape->get_polygon_count() > 0) {
PoolVector<Vector2> vertices = edited_navigation_shape->get_vertices();
for (int i = 0; i < edited_navigation_shape->get_polygon(0).size(); i++) {
current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]] + shape_anchor);
}
Fixing weird behaviour on autotile editor
2018-01-05 10:53:30 +00:00
}
}
}
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
workspace->update();
workspace_container->update();
helper->_change_notify("");
Fixing weird behaviour on autotile editor
2018-01-05 10:53:30 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
Vector2 TileSetEditor::snap_point(const Vector2 &point) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Vector2 p = point;
Vector2 coord = edited_shape_coord;
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 01:42:23 +00:00
Vector2 anchor = coord;
anchor.x *= (tile_size.x + spacing);
anchor.y *= (tile_size.y + spacing);
New TileSet Editor
2018-07-29 21:54:12 +00:00
anchor += tileset->tile_get_region(get_current_tile()).position;
anchor += WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Rect2 region(anchor, 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 20:10:01 +00:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:01 +00:00
region.size = tileset->tile_get_region(get_current_tile()).size;
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
Fix "seperate" typos
2019-10-31 12:40:58 +00: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 05:57:37 +00:00
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
if (tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
if (p.x < region.position.x)
p.x = region.position.x;
if (p.y < region.position.y)
p.y = region.position.y;
if (p.x > region.position.x + region.size.x)
p.x = region.position.x + region.size.x;
if (p.y > region.position.y + region.size.y)
p.y = region.position.y + region.size.y;
}
return p;
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
void TileSetEditor::add_texture(Ref<Texture> p_texture) {
texture_list->add_item(p_texture->get_path().get_file());
texture_map.insert(p_texture->get_rid(), p_texture);
texture_list->set_item_metadata(texture_list->get_item_count() - 1, p_texture->get_rid());
}
void TileSetEditor::remove_texture(Ref<Texture> p_texture) {
texture_list->remove_item(texture_list->find_metadata(p_texture->get_rid()));
texture_map.erase(p_texture->get_rid());
_validate_current_tile_id();
if (!get_current_texture().is_valid()) {
_on_texture_list_selected(-1);
workspace_overlay->update();
}
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::update_texture_list() {
Ref<Texture> selected_texture = get_current_texture();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
helper->set_tileset(tileset);
Implement auto-tiling
2017-10-22 01:42:23 +00:00
List<int> ids;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset->get_tile_list(&ids);
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 03:54:28 +00:00
Vector<int> ids_to_remove;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 03:54:28 +00: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());
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (!texture_map.has(tileset->tile_get_texture(E->get())->get_rid())) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
add_texture(tileset->tile_get_texture(E->get()));
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
}
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 03:54:28 +00:00
for (int i = 0; i < ids_to_remove.size(); i++) {
tileset->remove_tile(ids_to_remove[i]);
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (texture_list->get_item_count() > 0 && selected_texture.is_valid()) {
texture_list->select(texture_list->find_metadata(selected_texture->get_rid()));
if (texture_list->get_selected_items().size() > 0)
_on_texture_list_selected(texture_list->get_selected_items()[0]);
} else if (get_current_texture().is_valid()) {
_on_texture_list_selected(texture_list->find_metadata(get_current_texture()->get_rid()));
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
_validate_current_tile_id();
New TileSet Editor
2018-07-29 21:54:12 +00:00
_on_texture_list_selected(-1);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
workspace_overlay->update();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
update_texture_list_icon();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
helper->_change_notify("");
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TileSetEditor::update_texture_list_icon() {
for (int current_idx = 0; current_idx < texture_list->get_item_count(); current_idx++) {
RID rid = texture_list->get_item_metadata(current_idx);
texture_list->set_item_icon(current_idx, texture_map[rid]);
Fixed Tileset preview stretching textures
2019-03-05 02:35:49 +00:00
Size2 texture_size = texture_map[rid]->get_size();
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 11:08:44 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
texture_list->update();
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
void TileSetEditor::update_workspace_tile_mode() {
New TileSet Editor
2018-07-29 21:54:12 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 14:22:44 +00:00
tools[SELECT_NEXT]->set_disabled(true);
tools[SELECT_PREVIOUS]->set_disabled(true);
Add informational messages to various editors
2019-09-04 05:20:57 +00: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 04:38:26 +00: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 14:22:44 +00:00
tools[SELECT_NEXT]->set_disabled(false);
tools[SELECT_PREVIOUS]->set_disabled(false);
Add informational messages to various editors
2019-09-04 05:20:57 +00: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 04:38:26 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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-12 23:24:20 +00:00
separator_editmode->show();
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:45:16 +00:00
for (int i = TOOL_SELECT; i < ZOOM_OUT; i++) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
tools[i]->hide();
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_editmode->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
separator_bitmask->hide();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_delete->hide();
separator_grid->hide();
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
return;
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->show();
}
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
separator_editmode->show();
New TileSet Editor
2018-07-29 21:54:12 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Add Z-Index for Autotile
2018-07-02 13:39:39 +00: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 11:08:44 +00:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
New TileSet Editor
2018-07-29 21:54:12 +00:00
edit_mode = EDITMODE_COLLISION;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
select_coord(Vector2(0, 0));
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tool_editmode[EDITMODE_ICON]->hide();
tool_editmode[EDITMODE_BITMASK]->hide();
tool_editmode[EDITMODE_PRIORITY]->hide();
Add Z-Index for Autotile
2018-07-02 13:39:39 +00: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 17:17:52 +00:00
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (edit_mode == EDITMODE_ICON)
select_coord(tileset->autotile_get_icon_coordinate(get_current_tile()));
else
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
_select_edited_shape_coord();
New TileSet Editor
2018-07-29 21:54:12 +00: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;
}
if (edit_mode == EDITMODE_ICON)
select_coord(tileset->autotile_get_icon_coordinate(get_current_tile()));
else
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 16:20:49 +00:00
_select_edited_shape_coord();
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:09:11 +00:00
void TileSetEditor::update_workspace_minsize() {
Size2 workspace_min_size = get_current_texture()->get_size();
RID current_texture_rid = get_current_texture()->get_rid();
List<int> *tiles = new List<int>();
tileset->get_tile_list(tiles);
for (List<int>::Element *E = tiles->front(); E; E = E->next()) {
Fix TileSet editor's workspace size sometimes not changing correctly on region change
2020-01-10 03:57:49 +00:00
if (tileset->tile_get_texture(E->get())->get_rid() != current_texture_rid) {
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 01:09:11 +00:00
}
}
Fix memory leak in Tilemaps
2019-06-28 13:37:09 +00:00
delete tiles;
Make TileSet editor's workspace change size according to region changes
2019-02-28 01:09:11 +00:00
workspace->set_custom_minimum_size(workspace_min_size + WORKSPACE_MARGIN * 2);
Properly handle zoom when opening tileset editor
2019-11-12 15:23:30 +00: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);
Make TileSet editor's workspace change size according to region changes
2019-02-28 01:09:11 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:38:26 +00:00
grid_coord = ((region_from - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 21:54:12 +00:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 15:36:51 +00:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 21:54:12 +00:00
edited_region.expand_to(grid_coord);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
grid_coord = ((end_point - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 21:54:12 +00:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 15:36:51 +00:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 21:54:12 +00:00
edited_region.expand_to(grid_coord);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
} else {
New TileSet Editor
2018-07-29 21:54:12 +00:00
edited_region.expand_to(end_point);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00: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 03:04:31 +00:00
if (p_id == -1) {
editor->get_inspector()->edit(tileset.ptr());
} else {
editor->get_inspector()->edit(helper);
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
}
Ref<Texture> TileSetEditor::get_current_texture() {
if (texture_list->get_selected_items().size() == 0)
return Ref<Texture>();
Implement auto-tiling
2017-10-22 01:42:23 +00:00
else
New TileSet Editor
2018-07-29 21:54:12 +00:00
return texture_map[texture_list->get_item_metadata(texture_list->get_selected_items()[0])];
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TilesetEditorContext::set_tileset(const Ref<TileSet> &p_tileset) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset = p_tileset;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TilesetEditorContext::set_snap_options_visible(bool p_visible) {
snap_options_visible = p_visible;
_change_notify("");
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
bool TilesetEditorContext::_set(const StringName &p_name, const Variant &p_value) {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
String name = p_name.operator String();
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:08 +00:00
String name2 = p_name.operator String().right(5);
New TileSet Editor
2018-07-29 21:54:12 +00:00
bool v = false;
if (tileset_editor->get_current_tile() < 0 || tileset.is_null())
return false;
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 20:10:08 +00:00
if (name2 == "autotile_bitmask_mode") {
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:08 +00:00
} else if (name2 == "subtile_size") {
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:08 +00:00
} else if (name2 == "subtile_spacing") {
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:08 +00:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/" + name2, p_value, &v);
New TileSet Editor
2018-07-29 21:54:12 +00: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 20:10:01 +00: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 03:22:10 +00: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 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00: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 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
bool TilesetEditorContext::_get(const StringName &p_name, Variant &r_ret) const {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
String name = p_name.operator String();
Fix method not returning value in all paths (autotile editor)
2017-12-17 18:03:46 +00:00
bool v = false;
New TileSet Editor
2018-07-29 21:54:12 +00: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);
if (tileset_editor->get_current_tile() < 0 || tileset.is_null())
return false;
if (!tileset->has_tile(tileset_editor->get_current_tile()))
return false;
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 03:22:10 +00: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 21:54:12 +00: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 20:10:01 +00:00
} else if (name == "tileset_script") {
r_ret = tileset->get_script();
v = true;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Fix method not returning value in all paths (autotile editor)
2017-12-17 18:03:46 +00:00
return v;
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
void TilesetEditorContext::_get_property_list(List<PropertyInfo> *p_list) const {
Implement auto-tiling
2017-10-22 01:42:23 +00:00
New TileSet Editor
2018-07-29 21:54:12 +00:00
if (snap_options_visible) {
p_list->push_back(PropertyInfo(Variant::NIL, "Snap Options", PROPERTY_HINT_NONE, "options_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_offset"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_step"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "options_separation"));
}
if (tileset_editor->get_current_tile() >= 0 && !tileset.is_null()) {
int id = tileset_editor->get_current_tile();
p_list->push_back(PropertyInfo(Variant::NIL, "Selected Tile", PROPERTY_HINT_NONE, "tile_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::STRING, "tile_name"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "tile_normal_map", PROPERTY_HINT_RESOURCE_TYPE, "Texture"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_tex_offset"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "tile_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial"));
p_list->push_back(PropertyInfo(Variant::COLOR, "tile_modulate"));
p_list->push_back(PropertyInfo(Variant::INT, "tile_tile_mode", PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE"));
if (tileset->tile_get_tile_mode(id) == TileSet::AUTO_TILE) {
p_list->push_back(PropertyInfo(Variant::INT, "tile_autotile_bitmask_mode", PROPERTY_HINT_ENUM, "2X2,3X3 (minimal),3X3"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_subtile_size"));
p_list->push_back(PropertyInfo(Variant::INT, "tile_subtile_spacing", PROPERTY_HINT_RANGE, "0, 256, 1"));
} else if (tileset->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) {
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_subtile_size"));
p_list->push_back(PropertyInfo(Variant::INT, "tile_subtile_spacing", PROPERTY_HINT_RANGE, "0, 256, 1"));
}
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_occluder_offset"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_navigation_offset"));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_shape_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, "tile_shape_transform", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::INT, "tile_z_index", PROPERTY_HINT_RANGE, itos(VS::CANVAS_ITEM_Z_MIN) + "," + itos(VS::CANVAS_ITEM_Z_MAX) + ",1"));
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_COLLISION && tileset_editor->edited_collision_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "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 03:22:10 +00:00
if (tileset_editor->edited_collision_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::BOOL, "selected_collision_one_way", PROPERTY_HINT_NONE));
p_list->push_back(PropertyInfo(Variant::REAL, "selected_collision_one_way_margin", PROPERTY_HINT_NONE));
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_NAVIGATION && tileset_editor->edited_navigation_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "selected_navigation", PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_navigation_shape->get_class()));
}
if (tileset_editor->edit_mode == TileSetEditor::EDITMODE_OCCLUSION && tileset_editor->edited_occlusion_shape.is_valid()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "selected_occlusion", PROPERTY_HINT_RESOURCE_TYPE, tileset_editor->edited_occlusion_shape->get_class()));
}
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 20:10:01 +00:00
if (!tileset.is_null()) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "tileset_script", PROPERTY_HINT_RESOURCE_TYPE, "Script"));
}
Implement auto-tiling
2017-10-22 01:42:23 +00:00
}
Hide "Script" section in the "TilesetEditorContext"
2018-12-07 04:18:02 +00:00
void TilesetEditorContext::_bind_methods() {
Revert "Expose "meta" to the Inspector"
2019-07-22 10:03:57 +00:00
ClassDB::bind_method("_hide_script_from_inspector", &TilesetEditorContext::_hide_script_from_inspector);
Hide "Script" section in the "TilesetEditorContext"
2018-12-07 04:18:02 +00:00
}
New TileSet Editor
2018-07-29 21:54:12 +00:00
TilesetEditorContext::TilesetEditorContext(TileSetEditor *p_tileset_editor) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 20:42:29 +00:00
snap_options_visible = false;
Tileset Editor Improvement
2018-02-17 11:08:44 +00: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 21:54:12 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
bool TileSetEditorPlugin::handles(Object *p_node) const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
return p_node->is_class("TileSet") || p_node->is_class("TilesetEditorContext");
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
void TileSetEditorPlugin::make_visible(bool p_visible) {
if (p_visible) {
tileset_editor_button->show();
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
editor->make_bottom_panel_item_visible(tileset_editor);
New TileSet Editor
2018-07-29 21:54:12 +00:00
get_tree()->connect("idle_frame", tileset_editor, "_on_workspace_process");
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
} else {
Changes to the TileSet and TextureRegion editors
2018-08-12 23:24:20 +00:00
editor->hide_bottom_panel();
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset_editor_button->hide();
New TileSet Editor
2018-07-29 21:54:12 +00:00
get_tree()->disconnect("idle_frame", tileset_editor, "_on_workspace_process");
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 03:04:31 +00:00
state["show_information"] = tileset_editor->tools[TileSetEditor::VISIBLE_INFO]->is_pressed();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00: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 03:04:31 +00: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 04:38:26 +00: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 03:04:31 +00: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 04:38:26 +00:00
}
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) {
New TileSet Editor
2018-07-29 21:54:12 +00:00
editor = p_node;
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset_editor = memnew(TileSetEditor(p_node));
New TileSet Editor
2018-07-29 21:54:12 +00: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 04:35:48 +00:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 04:38:26 +00:00
tileset_editor_button = p_node->add_bottom_panel_item(TTR("TileSet"), tileset_editor);
Tileset Editor Improvement
2018-02-17 11:08:44 +00:00
tileset_editor_button->hide();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}