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

3419 lines
134 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* tile_set_editor_plugin.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2019 Happy new year to the wonderful Godot community!
2019-01-01 12:53:14 +01:00
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "tile_set_editor_plugin.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 08:04:19 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
#include "core/os/input.h"
#include "core/os/keyboard.h"
Implement auto-tiling
2017-10-22 03:42:23 +02:00
#include "editor/plugins/canvas_item_editor_plugin.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "scene/2d/physics_body_2d.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
#include "scene/2d/sprite.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 08:04:19 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
void TileSetEditor::edit(const Ref<TileSet> &p_tileset) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tileset = p_tileset;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->add_change_receptor(this);
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list->clear();
texture_map.clear();
update_texture_list();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
for (int i = 0; i < p_node->get_child_count(); i++) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
Node *child = p_node->get_child(i);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
if (!Object::cast_to<Sprite>(child)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (child->get_child_count() > 0) {
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
_import_node(child, p_library);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
continue;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
Sprite *mi = Object::cast_to<Sprite>(child);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Ref<Texture> texture = mi->get_texture();
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 17:15:50 +02:00
Ref<Texture> normal_map = mi->get_normal_map();
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
Ref<ShaderMaterial> material = mi->get_material();
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
if (texture.is_null())
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
continue;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
int id = p_library->find_tile_by_name(mi->get_name());
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (id < 0) {
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
id = p_library->get_last_unused_tile_id();
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
p_library->create_tile(id);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_name(id, mi->get_name());
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_texture(id, texture);
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 17:15:50 +02:00
p_library->tile_set_normal_map(id, normal_map);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_material(id, material);
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_modulate(id, mi->get_modulate());
Add modulate (color) to TileSet tiles
2016-11-30 14:33:39 +01:00
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Vector2 phys_offset;
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
Size2 s;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
if (mi->is_region()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
s = mi->get_region_rect().size;
p_library->tile_set_region(id, mi->get_region_rect());
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
} else {
const int frame = mi->get_frame();
const int hframes = mi->get_hframes();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
s = texture->get_size() / Size2(hframes, mi->get_vframes());
p_library->tile_set_region(id, Rect2(Vector2(frame % hframes, frame / hframes) * s, s));
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Respect frame property when converting to TileSet.
2016-07-05 20:40:22 +02:00
if (mi->is_centered()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
phys_offset += -s / 2;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
Vector<TileSet::ShapeData> collisions;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Ref<NavigationPolygon> nav_poly;
Ref<OccluderPolygon2D> occluder;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
bool found_collisions = false;
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int j = 0; j < mi->get_child_count(); j++) {
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
Node *child2 = mi->get_child(j);
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
if (Object::cast_to<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 06:34:56 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
if (Object::cast_to<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 06:34:56 +01:00
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
if (!Object::cast_to<StaticBody2D>(child2))
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
continue;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
found_collisions = true;
Convert Object::cast_to() to the static version Currently we rely on some undefined behavior when Object->cast_to() gets called with a Null pointer. This used to work fine with GCC < 6 but newer versions of GCC remove all codepaths in which the this pointer is Null. However, the non-static cast_to() was supposed to be null safe. This patch makes cast_to() Null safe and removes the now redundant Null checks where they existed. It is explained in this article: https://www.viva64.com/en/b/0226/
2017-08-24 22:58:51 +02:00
StaticBody2D *sb = Object::cast_to<StaticBody2D>(child2);
-Trigger shapes removed in 2D, they became obsolete long ago when areas could detect their own overlap -Added ability to disable individual collisionshape/polygon -Moved One Way Collision to shape, allowing more flexibility -Changed internals of CollisionObject, shapes are generated from child nodes on the fly, not stored inside any longer. -Modifying a CollisionPolygon2D on the fly now works, it can even be animated. Will port this to 3D once well tested. Have fun!
2017-06-24 04:30:43 +02:00
List<uint32_t> shapes;
sb->get_shape_owners(&shapes);
for (List<uint32_t>::Element *E = shapes.front(); E; E = E->next()) {
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02: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 04:30:43 +02:00
Fix bugs related to bad handling of rotated/translated shapes in tilemap Fixup #18529 and #12870
2018-06-03 15:32:23 +02:00
Transform2D shape_transform = sb->get_transform() * sb->shape_owner_get_transform(E->get());
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-25 20:47:30 +02:00
bool one_way = sb->is_shape_owner_one_way_collision_enabled(E->get());
Fix bugs related to bad handling of rotated/translated shapes in tilemap Fixup #18529 and #12870
2018-06-03 15:32:23 +02:00
shape_transform[2] -= phys_offset;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
-Trigger shapes removed in 2D, they became obsolete long ago when areas could detect their own overlap -Added ability to disable individual collisionshape/polygon -Moved One Way Collision to shape, allowing more flexibility -Changed internals of CollisionObject, shapes are generated from child nodes on the fly, not stored inside any longer. -Modifying a CollisionPolygon2D on the fly now works, it can even be animated. Will port this to 3D once well tested. Have fun!
2017-06-24 04:30:43 +02:00
for (int k = 0; k < sb->shape_owner_get_shape_count(E->get()); k++) {
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
Ref<Shape2D> shape = sb->shape_owner_get_shape(E->get(), k);
TileSet::ShapeData shape_data;
shape_data.shape = shape;
shape_data.shape_transform = shape_transform;
shape_data.one_way_collision = one_way;
collisions.push_back(shape_data);
Add all collision shapes to a tile when converting scenes to TileSets
2015-10-25 23:13:46 +01:00
}
heck
2014-04-19 21:46:52 +02:00
}
lot of work on 2D lighting and isometric maps added a new demo, isometric_light that does full isometric sorting, lights, shadows, etc.
2015-03-09 06:34:56 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-01 19:56:51 +02:00
if (found_collisions) {
p_library->tile_set_shapes(id, collisions);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_library->tile_set_texture_offset(id, mi->get_offset());
p_library->tile_set_navigation_polygon(id, nav_poly);
p_library->tile_set_light_occluder(id, occluder);
p_library->tile_set_occluder_offset(id, -phys_offset);
p_library->tile_set_navigation_polygon_offset(id, -phys_offset);
Adds z-index properties to TileSets.
2018-02-17 11:58:07 +01:00
p_library->tile_set_z_index(id, mi->get_z_index());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
}
Updated function argument names
2017-08-12 18:52:50 +02:00
void TileSetEditor::_import_scene(Node *p_scene, Ref<TileSet> p_library, bool p_merge) {
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
if (!p_merge)
p_library->clear();
Updated function argument names
2017-08-12 18:52:50 +02:00
_import_node(p_scene, p_library);
Fix #8819. Adds _import_node() that, when used in conjunction with _import_scene, recurses through the scene tree and exports all available nodes.
2017-05-19 23:49:37 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
void TileSetEditor::_undo_redo_import_scene(Node *p_scene, bool p_merge) {
_import_scene(p_scene, tileset, p_merge);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Error TileSetEditor::update_library_file(Node *p_base_scene, Ref<TileSet> ml, bool p_merge) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_import_scene(p_base_scene, ml, p_merge);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return OK;
}
void TileSetEditor::_bind_methods() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_undo_redo_import_scene", &TileSetEditor::_undo_redo_import_scene);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_tileset_toolbar_button_pressed", &TileSetEditor::_on_tileset_toolbar_button_pressed);
ClassDB::bind_method("_on_textures_added", &TileSetEditor::_on_textures_added);
ClassDB::bind_method("_on_tileset_toolbar_confirm", &TileSetEditor::_on_tileset_toolbar_confirm);
ClassDB::bind_method("_on_texture_list_selected", &TileSetEditor::_on_texture_list_selected);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_edit_mode_changed", &TileSetEditor::_on_edit_mode_changed);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_workspace_mode_changed", &TileSetEditor::_on_workspace_mode_changed);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
ClassDB::bind_method("_on_workspace_overlay_draw", &TileSetEditor::_on_workspace_overlay_draw);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_on_workspace_process", &TileSetEditor::_on_workspace_process);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_workspace_draw", &TileSetEditor::_on_workspace_draw);
ClassDB::bind_method("_on_workspace_input", &TileSetEditor::_on_workspace_input);
ClassDB::bind_method("_on_tool_clicked", &TileSetEditor::_on_tool_clicked);
ClassDB::bind_method("_on_priority_changed", &TileSetEditor::_on_priority_changed);
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
ClassDB::bind_method("_on_z_index_changed", &TileSetEditor::_on_z_index_changed);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
ClassDB::bind_method("_on_grid_snap_toggled", &TileSetEditor::_on_grid_snap_toggled);
New TileSet Editor
2018-07-29 23:54:12 +02:00
ClassDB::bind_method("_set_snap_step", &TileSetEditor::_set_snap_step);
ClassDB::bind_method("_set_snap_off", &TileSetEditor::_set_snap_off);
ClassDB::bind_method("_set_snap_sep", &TileSetEditor::_set_snap_sep);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_validate_current_tile_id", &TileSetEditor::_validate_current_tile_id);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
ClassDB::bind_method("_zoom_in", &TileSetEditor::_zoom_in);
ClassDB::bind_method("_zoom_out", &TileSetEditor::_zoom_out);
ClassDB::bind_method("_zoom_reset", &TileSetEditor::_zoom_reset);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("_select_edited_shape_coord", &TileSetEditor::_select_edited_shape_coord);
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
ClassDB::bind_method("_sort_tiles", &TileSetEditor::_sort_tiles);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
ClassDB::bind_method("edit", &TileSetEditor::edit);
ClassDB::bind_method("add_texture", &TileSetEditor::add_texture);
ClassDB::bind_method("remove_texture", &TileSetEditor::remove_texture);
ClassDB::bind_method("update_texture_list_icon", &TileSetEditor::update_texture_list_icon);
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
ClassDB::bind_method("update_workspace_minsize", &TileSetEditor::update_workspace_minsize);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_notification(int p_what) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
switch (p_what) {
case NOTIFICATION_READY: {
add_constant_override("autohide", 1); // Fixes the dragger always showing up.
} break;
case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: {
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_icon(get_icon("ToolAddNode", "EditorIcons"));
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_icon(get_icon("Remove", "EditorIcons"));
tileset_toolbar_tools->set_icon(get_icon("Tools", "EditorIcons"));
tool_workspacemode[WORKSPACE_EDIT]->set_icon(get_icon("Edit", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_SINGLE]->set_icon(get_icon("AddSingleTile", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_AUTOTILE]->set_icon(get_icon("AddAutotile", "EditorIcons"));
tool_workspacemode[WORKSPACE_CREATE_ATLAS]->set_icon(get_icon("AddAtlasTile", "EditorIcons"));
tools[TOOL_SELECT]->set_icon(get_icon("ToolSelect", "EditorIcons"));
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 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->set_icon(get_icon("CollisionShape2D", "EditorIcons"));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_PREVIOUS]->set_icon(get_icon("ArrowLeft", "EditorIcons"));
tools[SELECT_NEXT]->set_icon(get_icon("ArrowRight", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_icon(get_icon("Remove", "EditorIcons"));
tools[SHAPE_KEEP_INSIDE_TILE]->set_icon(get_icon("Snap", "EditorIcons"));
tools[TOOL_GRID_SNAP]->set_icon(get_icon("SnapGrid", "EditorIcons"));
tools[ZOOM_OUT]->set_icon(get_icon("ZoomLess", "EditorIcons"));
tools[ZOOM_1]->set_icon(get_icon("ZoomReset", "EditorIcons"));
tools[ZOOM_IN]->set_icon(get_icon("ZoomMore", "EditorIcons"));
tools[VISIBLE_INFO]->set_icon(get_icon("InformationSign", "EditorIcons"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_update_toggle_shape_button();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[EDITMODE_REGION]->set_icon(get_icon("RegionEdit", "EditorIcons"));
tool_editmode[EDITMODE_COLLISION]->set_icon(get_icon("StaticBody2D", "EditorIcons"));
tool_editmode[EDITMODE_OCCLUSION]->set_icon(get_icon("LightOccluder2D", "EditorIcons"));
tool_editmode[EDITMODE_NAVIGATION]->set_icon(get_icon("Navigation2D", "EditorIcons"));
tool_editmode[EDITMODE_BITMASK]->set_icon(get_icon("PackedDataContainer", "EditorIcons"));
tool_editmode[EDITMODE_PRIORITY]->set_icon(get_icon("MaterialPreviewLight1", "EditorIcons"));
tool_editmode[EDITMODE_ICON]->set_icon(get_icon("LargeTexture", "EditorIcons"));
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
tool_editmode[EDITMODE_Z_INDEX]->set_icon(get_icon("Sort", "EditorIcons"));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
scroll->add_style_override("bg", get_stylebox("bg", "Tree"));
} break;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
TileSetEditor::TileSetEditor(EditorNode *p_editor) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
editor = p_editor;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo = editor->get_undo_redo();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
current_tile = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
VBoxContainer *left_container = memnew(VBoxContainer);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
add_child(left_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list = memnew(ItemList);
left_container->add_child(texture_list);
texture_list->set_v_size_flags(SIZE_EXPAND_FILL);
texture_list->set_custom_minimum_size(Size2(200, 0));
texture_list->connect("item_selected", this, "_on_texture_list_selected");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
HBoxContainer *tileset_toolbar_container = memnew(HBoxContainer);
left_container->add_child(tileset_toolbar_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->connect("pressed", this, "_on_tileset_toolbar_button_pressed", varray(TOOL_TILESET_ADD_TEXTURE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_tooltip(TTR("Add Texture(s) to TileSet."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->connect("pressed", this, "_on_tileset_toolbar_button_pressed", varray(TOOL_TILESET_REMOVE_TEXTURE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_tooltip(TTR("Remove selected Texture from TileSet."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
Control *toolbar_separator = memnew(Control);
toolbar_separator->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tileset_toolbar_container->add_child(toolbar_separator);
tileset_toolbar_tools = memnew(MenuButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_toolbar_tools->set_text(TTR("Tools"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_tools->get_popup()->add_item(TTR("Create from Scene"), TOOL_TILESET_CREATE_SCENE);
tileset_toolbar_tools->get_popup()->add_item(TTR("Merge from Scene"), TOOL_TILESET_MERGE_SCENE);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_toolbar_tools->get_popup()->connect("id_pressed", this, "_on_tileset_toolbar_button_pressed");
tileset_toolbar_container->add_child(tileset_toolbar_tools);
//---------------
VBoxContainer *right_container = memnew(VBoxContainer);
right_container->set_v_size_flags(SIZE_EXPAND_FILL);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
add_child(right_container);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
dragging_point = -1;
creating_shape = false;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
snap_step = Vector2(32, 32);
New TileSet Editor
2018-07-29 23:54:12 +02:00
snap_offset = WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
set_custom_minimum_size(Size2(0, 150));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
VBoxContainer *main_vb = memnew(VBoxContainer);
New TileSet Editor
2018-07-29 23:54:12 +02:00
right_container->add_child(main_vb);
main_vb->set_v_size_flags(SIZE_EXPAND_FILL);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
HBoxContainer *tool_hb = memnew(HBoxContainer);
Ref<ButtonGroup> g(memnew(ButtonGroup));
New TileSet Editor
2018-07-29 23:54:12 +02:00
String workspace_label[WORKSPACE_MODE_MAX] = { "Edit", "New Single Tile", "New Autotile", "New Atlas" };
for (int i = 0; i < (int)WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i] = memnew(Button);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_workspacemode[i]->set_text(TTR(workspace_label[i]));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[i]->set_toggle_mode(true);
tool_workspacemode[i]->set_button_group(g);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_workspacemode[i]->connect("pressed", this, "_on_workspace_mode_changed", varray(i));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_hb->add_child(tool_workspacemode[i]);
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Control *spacer = memnew(Control);
spacer->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tool_hb->add_child(spacer);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_hb->move_child(spacer, WORKSPACE_CREATE_SINGLE);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_NEXT] = memnew(ToolButton);
tool_hb->add_child(tools[SELECT_NEXT]);
tool_hb->move_child(tools[SELECT_NEXT], WORKSPACE_CREATE_SINGLE);
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_shortcut(ED_SHORTCUT("tileset_editor/next_shape", TTR("Next Coordinate"), KEY_PAGEDOWN));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_NEXT]->connect("pressed", this, "_on_tool_clicked", varray(SELECT_NEXT));
tools[SELECT_NEXT]->set_tooltip(TTR("Select the next shape, subtile, or Tile."));
tools[SELECT_PREVIOUS] = memnew(ToolButton);
tool_hb->add_child(tools[SELECT_PREVIOUS]);
tool_hb->move_child(tools[SELECT_PREVIOUS], WORKSPACE_CREATE_SINGLE);
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_PREVIOUS]->set_shortcut(ED_SHORTCUT("tileset_editor/previous_shape", TTR("Previous Coordinate"), KEY_PAGEUP));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
tools[SELECT_PREVIOUS]->set_tooltip(TTR("Select the previous shape, subtile, or Tile."));
tools[SELECT_PREVIOUS]->connect("pressed", this, "_on_tool_clicked", varray(SELECT_PREVIOUS));
VSeparator *separator_shape_selection = memnew(VSeparator);
tool_hb->add_child(separator_shape_selection);
tool_hb->move_child(separator_shape_selection, WORKSPACE_CREATE_SINGLE);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
main_vb->add_child(tool_hb);
main_vb->add_child(memnew(HSeparator));
tool_hb = memnew(HBoxContainer);
g = Ref<ButtonGroup>(memnew(ButtonGroup));
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
String label[EDITMODE_MAX] = { "Region", "Collision", "Occlusion", "Navigation", "Bitmask", "Priority", "Icon", "Z Index" };
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < (int)EDITMODE_MAX; i++) {
tool_editmode[i] = memnew(Button);
tool_editmode[i]->set_text(label[i]);
tool_editmode[i]->set_toggle_mode(true);
tool_editmode[i]->set_button_group(g);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[i]->connect("pressed", this, "_on_edit_mode_changed", varray(i));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tool_hb->add_child(tool_editmode[i]);
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(tool_hb);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode = memnew(HSeparator);
main_vb->add_child(separator_editmode);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar = memnew(HBoxContainer);
Ref<ButtonGroup> tg(memnew(ButtonGroup));
tools[TOOL_SELECT] = memnew(ToolButton);
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[TOOL_SELECT]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_toggle_mode(true);
tools[TOOL_SELECT]->set_button_group(tg);
tools[TOOL_SELECT]->set_pressed(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[TOOL_SELECT]->connect("pressed", this, "_on_tool_clicked", varray(TOOL_SELECT));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask = memnew(VSeparator);
toolbar->add_child(separator_bitmask);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_COPY] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_COPY]->set_tooltip(TTR("Copy bitmask."));
tools[BITMASK_COPY]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_COPY));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_COPY]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_PASTE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_PASTE]->set_tooltip(TTR("Paste bitmask."));
tools[BITMASK_PASTE]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_PASTE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_PASTE]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[BITMASK_CLEAR] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[BITMASK_CLEAR]->set_tooltip(TTR("Erase bitmask."));
tools[BITMASK_CLEAR]->connect("pressed", this, "_on_tool_clicked", varray(BITMASK_CLEAR));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[BITMASK_CLEAR]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE] = memnew(ToolButton);
toolbar->add_child(tools[SHAPE_NEW_RECTANGLE]);
tools[SHAPE_NEW_RECTANGLE]->set_toggle_mode(true);
tools[SHAPE_NEW_RECTANGLE]->set_button_group(tg);
tools[SHAPE_NEW_RECTANGLE]->set_tooltip(TTR("Create a new rectangle."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_NEW_POLYGON] = memnew(ToolButton);
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[SHAPE_NEW_POLYGON]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_NEW_POLYGON]->set_toggle_mode(true);
tools[SHAPE_NEW_POLYGON]->set_button_group(tg);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_NEW_POLYGON]->set_tooltip(TTR("Create a new polygon."));
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
separator_shape_toggle = memnew(VSeparator);
toolbar->add_child(separator_shape_toggle);
tools[SHAPE_TOGGLE_TYPE] = memnew(ToolButton);
tools[SHAPE_TOGGLE_TYPE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_TOGGLE_TYPE));
toolbar->add_child(tools[SHAPE_TOGGLE_TYPE]);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete = memnew(VSeparator);
toolbar->add_child(separator_delete);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[SHAPE_DELETE] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->connect("pressed", this, "_on_tool_clicked", varray(SHAPE_DELETE));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[SHAPE_DELETE]);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority = memnew(SpinBox);
spin_priority->set_min(1);
spin_priority->set_max(255);
spin_priority->set_step(1);
spin_priority->set_custom_minimum_size(Size2(100, 0));
spin_priority->connect("value_changed", this, "_on_priority_changed");
spin_priority->hide();
toolbar->add_child(spin_priority);
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index = memnew(SpinBox);
spin_z_index->set_min(VS::CANVAS_ITEM_Z_MIN);
spin_z_index->set_max(VS::CANVAS_ITEM_Z_MAX);
spin_z_index->set_step(1);
spin_z_index->set_custom_minimum_size(Size2(100, 0));
spin_z_index->connect("value_changed", this, "_on_z_index_changed");
spin_z_index->hide();
toolbar->add_child(spin_z_index);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
separator_grid = memnew(VSeparator);
toolbar->add_child(separator_grid);
tools[SHAPE_KEEP_INSIDE_TILE] = memnew(ToolButton);
tools[SHAPE_KEEP_INSIDE_TILE]->set_toggle_mode(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_pressed(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_tooltip(TTR("Keep polygon inside region Rect."));
toolbar->add_child(tools[SHAPE_KEEP_INSIDE_TILE]);
tools[TOOL_GRID_SNAP] = memnew(ToolButton);
tools[TOOL_GRID_SNAP]->set_toggle_mode(true);
tools[TOOL_GRID_SNAP]->set_tooltip(TTR("Enable snap and show grid (configurable via the Inspector)."));
tools[TOOL_GRID_SNAP]->connect("toggled", this, "_on_grid_snap_toggled");
toolbar->add_child(tools[TOOL_GRID_SNAP]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Control *separator = memnew(Control);
separator->set_h_size_flags(SIZE_EXPAND_FILL);
toolbar->add_child(separator);
tools[ZOOM_OUT] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_OUT]->connect("pressed", this, "_zoom_out");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_OUT]);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[ZOOM_OUT]->set_tooltip(TTR("Zoom Out"));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[ZOOM_1] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_1]->connect("pressed", this, "_zoom_reset");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_1]);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_1]->set_tooltip(TTR("Zoom Reset"));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[ZOOM_IN] = memnew(ToolButton);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[ZOOM_IN]->connect("pressed", this, "_zoom_in");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
toolbar->add_child(tools[ZOOM_IN]);
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[ZOOM_IN]->set_tooltip(TTR("Zoom In"));
tools[VISIBLE_INFO] = memnew(ToolButton);
tools[VISIBLE_INFO]->set_toggle_mode(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[VISIBLE_INFO]->set_tooltip(TTR("Display Tile Names (Hold Alt Key)"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
toolbar->add_child(tools[VISIBLE_INFO]);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(toolbar);
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
scroll = memnew(ScrollContainer);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
main_vb->add_child(scroll);
scroll->set_v_size_flags(SIZE_EXPAND_FILL);
New TileSet Editor
2018-07-29 23:54:12 +02:00
scroll->set_clip_contents(true);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace_container = memnew(Control);
scroll->add_child(workspace_container);
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace_overlay = memnew(Control);
workspace_overlay->connect("draw", this, "_on_workspace_overlay_draw");
workspace_container->add_child(workspace_overlay);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace = memnew(Control);
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->set_focus_mode(FOCUS_ALL);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->connect("draw", this, "_on_workspace_draw");
workspace->connect("gui_input", this, "_on_workspace_input");
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace->set_draw_behind_parent(true);
workspace_overlay->add_child(workspace);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
preview = memnew(Sprite);
workspace->add_child(preview);
preview->set_centered(false);
preview->set_draw_behind_parent(true);
New TileSet Editor
2018-07-29 23:54:12 +02:00
preview->set_position(WORKSPACE_MARGIN);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
cd = memnew(ConfirmationDialog);
add_child(cd);
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->connect("confirmed", this, "_on_tileset_toolbar_confirm");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
err_dialog = memnew(AcceptDialog);
add_child(err_dialog);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
//---------------
texture_dialog = memnew(EditorFileDialog);
texture_dialog->set_access(EditorFileDialog::ACCESS_RESOURCES);
texture_dialog->set_mode(EditorFileDialog::MODE_OPEN_FILES);
texture_dialog->clear_filters();
List<String> extensions;
ResourceLoader::get_recognized_extensions_for_type("Texture", &extensions);
for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02: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 17:35:12 +01:00
tile_names_visible = false;
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
// config scale
max_scale = 10.0f;
min_scale = 0.1f;
scale_ratio = 1.2f;
fix updating tileset list when assign texture and set autotile true
2018-01-10 23:45:14 +01:00
}
TileSetEditorPlgn: Fix a leak
2018-02-27 03:54:09 +01:00
TileSetEditor::~TileSetEditor() {
if (helper)
memdelete(helper);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_tileset_toolbar_button_pressed(int p_index) {
option = p_index;
switch (option) {
case TOOL_TILESET_ADD_TEXTURE: {
texture_dialog->popup_centered_ratio();
} break;
case TOOL_TILESET_REMOVE_TEXTURE: {
if (get_current_texture().is_valid()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
cd->set_text(TTR("Remove selected texture? This will remove all tiles which use it."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->popup_centered(Size2(300, 60));
} else {
err_dialog->set_text(TTR("You haven't selected a texture to remove."));
err_dialog->popup_centered(Size2(300, 60));
}
} break;
case TOOL_TILESET_CREATE_SCENE: {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
cd->set_text(TTR("Create from scene? This will overwrite all current tiles."));
New TileSet Editor
2018-07-29 23:54:12 +02:00
cd->popup_centered(Size2(300, 60));
} break;
case TOOL_TILESET_MERGE_SCENE: {
cd->set_text(TTR("Merge from scene?"));
cd->popup_centered(Size2(300, 60));
} break;
}
}
void TileSetEditor::_on_tileset_toolbar_confirm() {
switch (option) {
case TOOL_TILESET_REMOVE_TEXTURE: {
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 17:20:49 +01:00
undo_redo->create_action(TTR("Remove Texture"));
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
if (tileset->tile_get_texture(E->get())->get_rid() == current_rid) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "remove_tile", E->get());
_undo_tile_removal(E->get());
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "remove_texture", get_current_texture());
undo_redo->add_undo_method(this, "add_texture", get_current_texture());
undo_redo->add_undo_method(this, "update_texture_list_icon");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
case TOOL_TILESET_MERGE_SCENE:
case TOOL_TILESET_CREATE_SCENE: {
EditorNode *en = editor;
Node *scene = en->get_edited_scene();
if (!scene)
break;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
List<int> ids;
tileset->get_tile_list(&ids);
undo_redo->create_action(TTR(option == TOOL_TILESET_MERGE_SCENE ? "Merge Tileset from Scene" : "Create Tileset from Scene"));
undo_redo->add_do_method(this, "_undo_redo_import_scene", scene, option == TOOL_TILESET_MERGE_SCENE);
undo_redo->add_undo_method(tileset.ptr(), "clear");
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
_undo_tile_removal(E->get());
}
undo_redo->add_do_method(this, "edit", tileset);
undo_redo->add_undo_method(this, "edit", tileset);
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
}
}
void TileSetEditor::_on_texture_list_selected(int p_index) {
if (get_current_texture().is_valid()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
current_item_index = p_index;
New TileSet Editor
2018-07-29 23:54:12 +02:00
preview->set_texture(get_current_texture());
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
update_workspace_tile_mode();
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
update_workspace_minsize();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
current_item_index = -1;
preview->set_texture(NULL);
workspace->set_custom_minimum_size(Size2i());
New TileSet Editor
2018-07-29 23:54:12 +02:00
update_workspace_tile_mode();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
set_current_tile(-1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_textures_added(const PoolStringArray &p_paths) {
int invalid_count = 0;
for (int i = 0; i < p_paths.size(); i++) {
Ref<Texture> t = Ref<Texture>(ResourceLoader::load(p_paths[i]));
TileSetEditor: Don't crash when adding invalid files
2018-10-11 17:13:44 +02:00
ERR_EXPLAIN("'" + p_paths[i] + "' is not a valid texture.");
ERR_CONTINUE(!t.is_valid());
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (texture_map.has(t->get_rid())) {
invalid_count++;
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
add_texture(t);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
TileSetEditor: Don't crash when adding invalid files
2018-10-11 17:13:44 +02:00
if (texture_list->get_item_count() > 0) {
update_texture_list_icon();
texture_list->select(texture_list->get_item_count() - 1);
_on_texture_list_selected(texture_list->get_item_count() - 1);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (invalid_count > 0) {
Fix vformat(), minor typos and word puzzles
2018-08-28 20:15:04 +02:00
err_dialog->set_text(vformat(TTR("%s file(s) were not added because was already on the list."), String::num(invalid_count, 0)));
New TileSet Editor
2018-07-29 23:54:12 +02:00
err_dialog->popup_centered(Size2(300, 60));
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_edit_mode_changed(int p_edit_mode) {
Fixes editor crashing when editing autotiles issue #24004
2018-12-06 10:35:38 +01:00
draw_handles = false;
creating_shape = false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
edit_mode = (EditMode)p_edit_mode;
switch (edit_mode) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
case EDITMODE_REGION: {
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
if (workspace_mode == WORKSPACE_EDIT) {
separator_delete->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
} else {
separator_delete->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
}
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_GRID_SNAP]->show();
tools[TOOL_SELECT]->set_pressed(true);
tools[TOOL_SELECT]->set_tooltip(TTR("Drag handles to edit Rect.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete selected Rect."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_COLLISION:
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->show();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->show();
tools[TOOL_GRID_SNAP]->show();
tools[TOOL_SELECT]->set_tooltip(TTR("Select current edited sub-tile.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tools[SHAPE_DELETE]->set_tooltip(TTR("Delete polygon."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
case EDITMODE_BITMASK: {
tools[TOOL_SELECT]->show();
separator_bitmask->show();
tools[BITMASK_COPY]->show();
tools[BITMASK_PASTE]->show();
tools[BITMASK_CLEAR]->show();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_delete->hide();
tools[SHAPE_DELETE]->hide();
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_SELECT]->set_pressed(true);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("LMB: Set bit on.\nRMB: Set bit off.\nShift+LMB: Set wildcard bit.\nClick on another Tile to edit it."));
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
spin_priority->hide();
} break;
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_Z_INDEX:
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
case EDITMODE_PRIORITY:
case EDITMODE_ICON: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->show();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[BITMASK_COPY]->hide();
tools[BITMASK_PASTE]->hide();
tools[BITMASK_CLEAR]->hide();
tools[SHAPE_NEW_POLYGON]->hide();
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
tools[SHAPE_NEW_RECTANGLE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_DELETE]->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_grid->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[SHAPE_KEEP_INSIDE_TILE]->hide();
tools[TOOL_GRID_SNAP]->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (edit_mode == EDITMODE_ICON) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to use as icon, this will be also used on invalid autotile bindings.\nClick on another Tile to edit it."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
} else if (edit_mode == EDITMODE_PRIORITY) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to change its priority.\nClick on another Tile to edit it."));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
spin_priority->show();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
spin_z_index->hide();
} else {
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to change its z index.\nClick on another Tile to edit it."));
spin_priority->hide();
spin_z_index->show();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_update_toggle_shape_button();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_workspace_mode_changed(int p_workspace_mode) {
workspace_mode = (WorkspaceMode)p_workspace_mode;
if (p_workspace_mode == WORKSPACE_EDIT) {
update_workspace_tile_mode();
} else {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
tool_editmode[EDITMODE_REGION]->show();
tool_editmode[EDITMODE_REGION]->set_pressed(true);
_on_edit_mode_changed(EDITMODE_REGION);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_workspace_draw() {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (tileset.is_null() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
const Color COLOR_AUTOTILE = Color(0.3, 0.6, 1);
const Color COLOR_SINGLE = Color(1, 1, 0.3);
const Color COLOR_ATLAS = Color(0.8, 0.8, 0.8);
const Color COLOR_SUBDIVISION = Color(0.3, 0.7, 0.6);
draw_handles = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_current_tile();
draw_grid_snap();
if (get_current_tile() >= 0) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Rect2i region = tileset->tile_get_region(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
switch (edit_mode) {
case EDITMODE_ICON: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = tileset->autotile_get_icon_coordinate(get_current_tile());
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_subtile(coord);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_BITMASK: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Color c(1, 0, 0, 0.5);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
Color ci(0.3, 0.6, 1, 0.5);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (float x = 0; x < region.size.x / (spacing + size.x); x++) {
for (float y = 0; y < region.size.y / (spacing + size.y); y++) {
Vector2 coord(x, y);
Point2 anchor(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += region.position;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 4), ci);
workspace->draw_rect(Rect2(anchor + size / 4, size / 4), ci);
} else if (mask & TileSet::BIND_TOPLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor, size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPRIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, 0), size / 4), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 3 / 4, size.y / 4), size / 4), ci);
} else if (mask & TileSet::BIND_TOPRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, 0), size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMLEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 2), size / 4), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 4, size.y * 3 / 4), size / 4), ci);
} else if (mask & TileSet::BIND_BOTTOMLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 2), size / 2), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMRIGHT) {
workspace->draw_rect(Rect2(anchor + size / 2, size / 4), ci);
workspace->draw_rect(Rect2(anchor + size * 3 / 4, size / 4), ci);
} else if (mask & TileSet::BIND_BOTTOMRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + size / 2, size / 2), c);
}
Restore support for minimal 3x3 autotile sets
2018-05-17 05:39:43 +02:00
} else {
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size / 6, size / 6), ci);
} else if (mask & TileSet::BIND_TOPLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor, size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOP) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, 0), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, size.y / 6), size / 6), ci);
} else if (mask & TileSet::BIND_TOP) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, 0), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_TOPRIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 4 / 6, 0), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 5 / 6, size.y / 6), size / 6), ci);
} else if (mask & TileSet::BIND_TOPRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, 0), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_LEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 3), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 6, size.y / 2), size / 6), ci);
} else if (mask & TileSet::BIND_LEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_CENTER) {
workspace->draw_rect(Rect2(anchor + size / 3, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size / 2, size / 6), ci);
} else if (mask & TileSet::BIND_CENTER) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_RIGHT) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 4 / 6, size.y / 3), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x * 5 / 6, size.y / 2), size / 6), ci);
} else if (mask & TileSet::BIND_RIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, size.y / 3), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMLEFT) {
workspace->draw_rect(Rect2(anchor + Vector2(0, size.y * 4 / 6), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 6, size.y * 5 / 6), size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOMLEFT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(0, (size.y / 3) * 2), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOM) {
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, size.y * 4 / 6), size / 6), ci);
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, size.y * 5 / 6), size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOM) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, (size.y / 3) * 2), size / 3), c);
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
if (mask & TileSet::BIND_IGNORE_BOTTOMRIGHT) {
workspace->draw_rect(Rect2(anchor + size * 4 / 6, size / 6), ci);
workspace->draw_rect(Rect2(anchor + size * 5 / 6, size / 6), ci);
} else if (mask & TileSet::BIND_BOTTOMRIGHT) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->draw_rect(Rect2(anchor + (size / 3) * 2, size / 3), c);
}
}
}
}
} break;
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = edited_shape_coord;
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_subtile(coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
draw_polygon_shapes();
Autotile Enhancement
2017-12-28 06:57:37 +01:00
draw_grid_snap();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
case EDITMODE_PRIORITY: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
spin_priority->set_value(tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t mask = tileset->autotile_get_bitmask(get_current_tile(), edited_shape_coord);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> queue_others;
int total = 0;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (E->value() == mask) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
total += tileset->autotile_get_subtile_priority(get_current_tile(), E->key());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (E->key() != edited_shape_coord) {
queue_others.push_back(E->key());
}
}
}
spin_priority->set_suffix(" / " + String::num(total, 0));
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_highlight_subtile(edited_shape_coord, queue_others);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} break;
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_Z_INDEX: {
spin_z_index->set_value(tileset->autotile_get_z_index(get_current_tile(), edited_shape_coord));
draw_highlight_subtile(edited_shape_coord);
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
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 05:38:26 +01: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 23:54:12 +02: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 05:38:26 +01:00
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(region, c, false);
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (edit_mode == EDITMODE_REGION) {
if (workspace_mode != WORKSPACE_EDIT) {
Rect2i region = edited_region;
Color c;
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 22:52:56 +01:00
if (t_id < 0)
return;
New TileSet Editor
2018-07-29 23:54:12 +02: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 03:42:23 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (draw_edited_region)
draw_edited_region_subdivision();
else
draw_tile_subdivision(t_id, COLOR_SUBDIVISION);
New TileSet Editor
2018-07-29 23:54:12 +02: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 03:42:23 +02:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
workspace_overlay->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_on_workspace_process() {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
if (Input::get_singleton()->is_key_pressed(KEY_ALT) || tools[VISIBLE_INFO]->is_pressed()) {
if (!tile_names_visible) {
tile_names_visible = true;
workspace_overlay->update();
}
} else if (tile_names_visible) {
tile_names_visible = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace_overlay->update();
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
void TileSetEditor::_on_workspace_overlay_draw() {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (!tileset.is_valid() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 23:54:12 +02: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 17:35:12 +01:00
if (tile_names_visible) {
New TileSet Editor
2018-07-29 23:54:12 +02: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();
if (tileset->tile_get_texture(t_id)->get_rid() == current_texture_rid) {
Rect2i 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;
Display tile ID along with name Fixes #20895.
2018-08-18 15:39:50 +02:00
String tile_id_name = String::num(t_id, 0) + ": " + tileset->tile_get_name(t_id);
New TileSet Editor
2018-07-29 23:54:12 +02:00
Ref<Font> font = get_font("font", "Label");
Display tile ID along with name Fixes #20895.
2018-08-18 15:39:50 +02:00
region.set_size(font->get_string_size(tile_id_name));
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace_overlay->draw_rect(region, c);
region.position.y += region.size.y - 2;
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
c = Color(0.1, 0.1, 0.1);
Display tile ID along with name Fixes #20895.
2018-08-18 15:39:50 +02:00
workspace_overlay->draw_string(font, region.position, tile_id_name, c);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
int t_id = get_current_tile();
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (t_id < 0)
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
return;
Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (draw_handles) {
for (int i = 0; i < current_shape.size(); i++) {
workspace_overlay->draw_texture(handle, current_shape[i] * workspace->get_scale().x - handle->get_size() * 0.5);
}
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (tileset.is_null() || !get_current_texture().is_valid())
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
static bool dragging;
static bool erasing;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
static bool alternative;
New TileSet Editor
2018-07-29 23:54:12 +02:00
draw_edited_region = false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 current_tile_region = Rect2();
if (get_current_tile() >= 0) {
current_tile_region = tileset->tile_get_region(get_current_tile());
}
current_tile_region.position += WORKSPACE_MARGIN;
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 19:10:13 +01:00
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && !creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (!current_tile_region.has_point(mb->get_position())) {
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();
return;
}
}
}
}
}
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
// Mouse Wheel Event
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01: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 15:56:05 +02:00
_zoom_in();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01: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 15:56:05 +02:00
_zoom_out();
}
New TileSet Editor
2018-07-29 23:54:12 +02: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 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (edit_mode == EDITMODE_REGION) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (get_current_tile() >= 0 || workspace_mode != WORKSPACE_EDIT) {
dragging = true;
region_from = mb->get_position();
edited_region = Rect2(region_from, Size2());
workspace->update();
workspace_overlay->update();
return;
}
} else if (dragging && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
dragging = false;
edited_region = Rect2();
workspace->update();
workspace_overlay->update();
return;
} else if (dragging && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
dragging = false;
update_edited_region(mb->get_position());
edited_region.position -= WORKSPACE_MARGIN;
if (!edited_region.has_no_area()) {
if (get_current_tile() >= 0 && workspace_mode == WORKSPACE_EDIT) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Set Tile Region"));
undo_redo->add_do_method(tileset.ptr(), "tile_set_region", get_current_tile(), edited_region);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_region", get_current_tile(), tileset->tile_get_region(get_current_tile()));
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Size2 tile_workspace_size = edited_region.position + edited_region.size + WORKSPACE_MARGIN * 2;
Size2 workspace_minsize = workspace->get_custom_minimum_size();
if (tile_workspace_size.x > workspace_minsize.x && tile_workspace_size.y > workspace_minsize.y) {
undo_redo->add_do_method(workspace, "set_custom_minimum_size", tile_workspace_size);
undo_redo->add_undo_method(workspace, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_container, "set_custom_minimum_size", tile_workspace_size);
undo_redo->add_undo_method(workspace_container, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_overlay, "set_custom_minimum_size", tile_workspace_size);
undo_redo->add_undo_method(workspace_overlay, "set_custom_minimum_size", workspace_minsize);
} else if (workspace_minsize.x > get_current_texture()->get_size().x + WORKSPACE_MARGIN.x * 2 || workspace_minsize.y > get_current_texture()->get_size().y + WORKSPACE_MARGIN.y * 2) {
undo_redo->add_do_method(this, "update_workspace_minsize");
undo_redo->add_undo_method(this, "update_workspace_minsize");
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_region = Rect2();
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
int t_id = tileset->get_last_unused_tile_id();
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Tile"));
undo_redo->add_do_method(tileset.ptr(), "create_tile", t_id);
undo_redo->add_undo_method(tileset.ptr(), "remove_tile", t_id);
undo_redo->add_undo_method(this, "_validate_current_tile_id");
undo_redo->add_do_method(tileset.ptr(), "tile_set_texture", t_id, get_current_texture());
undo_redo->add_do_method(tileset.ptr(), "tile_set_region", t_id, edited_region);
undo_redo->add_do_method(tileset.ptr(), "tile_set_name", t_id, get_current_texture()->get_path().get_file() + " " + String::num(t_id, 0));
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode != WORKSPACE_CREATE_SINGLE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "autotile_set_size", t_id, snap_step);
undo_redo->add_do_method(tileset.ptr(), "autotile_set_spacing", t_id, snap_separation.x);
undo_redo->add_do_method(tileset.ptr(), "tile_set_tile_mode", t_id, workspace_mode == WORKSPACE_CREATE_AUTOTILE ? TileSet::AUTO_TILE : TileSet::ATLAS_TILE);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Size2 tile_workspace_size = edited_region.position + edited_region.size + WORKSPACE_MARGIN * 2;
Size2 workspace_minsize = workspace->get_custom_minimum_size();
if (tile_workspace_size.x > workspace_minsize.x || tile_workspace_size.y > workspace_minsize.y) {
Size2 new_workspace_minsize = Size2(MAX(tile_workspace_size.x, workspace_minsize.x), MAX(tile_workspace_size.y, workspace_minsize.y));
undo_redo->add_do_method(workspace, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_container, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace_container, "set_custom_minimum_size", workspace_minsize);
undo_redo->add_do_method(workspace_overlay, "set_custom_minimum_size", new_workspace_minsize);
undo_redo->add_undo_method(workspace_overlay, "set_custom_minimum_size", workspace_minsize);
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
edited_region = Rect2();
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
set_current_tile(t_id);
New TileSet Editor
2018-07-29 23:54:12 +02:00
_on_workspace_mode_changed(WORKSPACE_EDIT);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
} else {
edited_region = Rect2();
workspace->update();
workspace_overlay->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
}
} else if (mm.is_valid()) {
if (dragging) {
update_edited_region(mm->get_position());
draw_edited_region = true;
workspace->update();
workspace_overlay->update();
return;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (workspace_mode == WORKSPACE_EDIT) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (get_current_tile() >= 0) {
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
switch (edit_mode) {
case EDITMODE_ICON: {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && current_tile_region.has_point(mb->get_position())) {
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Set Tile Icon"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_icon_coordinate", get_current_tile(), coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_icon_coordinate", get_current_tile(), tileset->autotile_get_icon_coordinate(get_current_tile()));
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} break;
case EDITMODE_BITMASK: {
if (mb.is_valid()) {
if (mb->is_pressed()) {
if (dragging) {
return;
}
if ((mb->get_button_index() == BUTTON_RIGHT || mb->get_button_index() == BUTTON_LEFT) && current_tile_region.has_point(mb->get_position())) {
dragging = true;
erasing = (mb->get_button_index() == BUTTON_RIGHT);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
alternative = Input::get_singleton()->is_key_pressed(KEY_SHIFT);
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
pos = mb->get_position() - (pos + current_tile_region.position);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t bit = 0;
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
} else {
bit = TileSet::BIND_BOTTOMLEFT;
}
} else {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPRIGHT;
} else {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
} else {
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMLEFT;
} else {
bit = TileSet::BIND_LEFT;
}
} else if (pos.x > (size.x / 3) * 2) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPRIGHT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMRIGHT;
} else {
bit = TileSet::BIND_RIGHT;
}
} else {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOP;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOM;
} else {
bit = TileSet::BIND_CENTER;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t old_mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
uint32_t new_mask = old_mask;
if (alternative) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask &= ~bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask |= (bit << 16);
} else if (erasing) {
new_mask &= ~bit;
new_mask &= ~(bit << 16);
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask |= bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (old_mask != new_mask) {
undo_redo->create_action(TTR("Edit Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, new_mask);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, old_mask);
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} else {
if ((erasing && mb->get_button_index() == BUTTON_RIGHT) || (!erasing && mb->get_button_index() == BUTTON_LEFT)) {
dragging = false;
erasing = false;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
alternative = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (mm.is_valid()) {
if (dragging && current_tile_region.has_point(mm->get_position())) {
Vector2 coord((int)((mm->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mm->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
New TileSet Editor
2018-07-29 23:54:12 +02:00
pos = mm->get_position() - (pos + current_tile_region.position);
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t bit = 0;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
} else {
bit = TileSet::BIND_BOTTOMLEFT;
}
} else {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPRIGHT;
} else {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
Restore support for minimal 3x3 autotile sets
2018-05-17 05:39:43 +02:00
} else {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMLEFT;
} else {
bit = TileSet::BIND_LEFT;
}
} else if (pos.x > (size.x / 3) * 2) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPRIGHT;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOMRIGHT;
} else {
bit = TileSet::BIND_RIGHT;
}
} else {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOP;
} else if (pos.y > (size.y / 3) * 2) {
bit = TileSet::BIND_BOTTOM;
} else {
bit = TileSet::BIND_CENTER;
}
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
uint32_t old_mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
uint32_t new_mask = old_mask;
if (alternative) {
new_mask &= ~bit;
new_mask |= (bit << 16);
} else if (erasing) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask &= ~bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
new_mask |= bit;
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
new_mask &= ~(bit << 16);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
if (old_mask != new_mask) {
undo_redo->create_action(TTR("Edit Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, new_mask);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), coord, old_mask);
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector2 shape_anchor = Vector2(0, 0);
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
const real_t grab_threshold = EDITOR_GET("editors/poly_editor/point_grab_radius");
New TileSet Editor
2018-07-29 23:54:12 +02:00
shape_anchor += current_tile_region.position;
if (tools[TOOL_SELECT]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (edit_mode != EDITMODE_PRIORITY && current_shape.size() > 0) {
for (int i = 0; i < current_shape.size(); i++) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if ((current_shape[i] - mb->get_position()).length_squared() <= grab_threshold) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
dragging_point = i;
workspace->update();
return;
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if ((tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) && current_tile_region.has_point(mb->get_position())) {
Vector2 coord((int)((mb->get_position().x - current_tile_region.position.x) / (spacing + size.x)), (int)((mb->get_position().y - current_tile_region.position.y) / (spacing + size.y)));
if (edited_shape_coord != coord) {
edited_shape_coord = coord;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
_select_edited_shape_coord();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
} else if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
if (edit_mode == EDITMODE_COLLISION) {
if (dragging_point >= 0) {
dragging_point = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
Vector<Vector2> points;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (int i = 0; i < current_shape.size(); i++) {
Vector2 p = current_shape[i];
if (tools[TOOL_GRID_SNAP]->is_pressed() || tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
p = snap_point(p);
}
points.push_back(p - shape_anchor);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Collision Polygon"));
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_shape_points(points);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
if (dragging_point >= 0) {
dragging_point = -1;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
PoolVector<Vector2> polygon;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
w = PoolVector<Vector2>::Write();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Occlusion Polygon"));
undo_redo->add_do_method(edited_occlusion_shape.ptr(), "set_polygon", polygon);
undo_redo->add_undo_method(edited_occlusion_shape.ptr(), "set_polygon", edited_occlusion_shape->get_polygon());
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (edit_mode == EDITMODE_NAVIGATION) {
if (dragging_point >= 0) {
dragging_point = -1;
PoolVector<Vector2> polygon;
Vector<int> indices;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
indices.push_back(i);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
w = PoolVector<Vector2>::Write();
fix crash autotile edit mode
2018-02-16 11:48:01 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Edit Navigation Polygon"));
undo_redo->add_do_method(edited_navigation_shape.ptr(), "set_vertices", polygon);
undo_redo->add_undo_method(edited_navigation_shape.ptr(), "set_vertices", edited_navigation_shape->get_vertices());
undo_redo->add_do_method(edited_navigation_shape.ptr(), "add_polygon", indices);
undo_redo->add_undo_method(edited_navigation_shape.ptr(), "add_polygon", edited_navigation_shape->get_polygon(0));
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
} else if (mm.is_valid()) {
if (dragging_point >= 0) {
current_shape.set(dragging_point, snap_point(mm->get_position()));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
} else if (tools[SHAPE_NEW_POLYGON]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
Vector2 pos = mb->get_position();
pos = snap_point(pos);
if (creating_shape) {
if (current_shape.size() > 0) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if ((pos - current_shape[0]).length_squared() <= grab_threshold) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (current_shape.size() > 2) {
close_shape(shape_anchor);
workspace->update();
return;
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
current_shape.push_back(pos);
workspace->update();
} else {
creating_shape = true;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>());
New TileSet Editor
2018-07-29 23:54:12 +02:00
current_shape.resize(0);
current_shape.push_back(snap_point(pos));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
} else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (creating_shape) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
creating_shape = false;
_select_edited_shape_coord();
workspace->update();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (mm.is_valid()) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
} else if (tools[SHAPE_NEW_RECTANGLE]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>());
Added a create rectangle button to the tileset editor. It makes easier to create collision shapes covering the full tile.
2019-02-20 12:27:53 +01:00
current_shape.resize(0);
current_shape.push_back(snap_point(shape_anchor));
current_shape.push_back(snap_point(shape_anchor + Vector2(current_tile_region.size.x, 0)));
current_shape.push_back(snap_point(shape_anchor + current_tile_region.size));
current_shape.push_back(snap_point(shape_anchor + Vector2(0, current_tile_region.size.y)));
close_shape(shape_anchor);
workspace->update();
} else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
workspace->update();
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_tool_clicked(int p_tool) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (p_tool == BITMASK_COPY) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
bitmask_map_copy = tileset->autotile_get_bitmask_map(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == BITMASK_PASTE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Paste Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
undo_redo->add_undo_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = bitmask_map_copy.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
}
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == BITMASK_CLEAR) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Clear Tile Bitmask"));
undo_redo->add_do_method(tileset.ptr(), "autotile_clear_bitmask_map", get_current_tile());
+ Added ignore flags to autotile bitmask + Added ignore functionality to tileset editor + Updated tileset editor autotile tooltip + Autotile ignore bits are processed and rendered correctl
2019-03-31 19:28:42 +02:00
for (Map<Vector2, uint32_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", get_current_tile(), E->key(), E->value());
}
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->commit_action();
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
} else if (p_tool == SHAPE_TOGGLE_TYPE) {
if (edited_collision_shape.is_valid()) {
Ref<ConvexPolygonShape2D> convex = edited_collision_shape;
Ref<ConcavePolygonShape2D> concave = edited_collision_shape;
Ref<Shape2D> previous_shape = edited_collision_shape;
Array sd = tileset->call("tile_get_shapes", get_current_tile());
if (convex.is_valid()) {
// 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));
} else {
// Shoudn't haphen
}
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-03-01 00:48:34 +01:00
} else if (p_tool == SELECT_NEXT) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_select_next_shape();
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
} else if (p_tool == SELECT_PREVIOUS) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_select_previous_shape();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (p_tool == SHAPE_DELETE) {
TileMap Fixes
2017-12-01 01:50:09 +01:00
if (creating_shape) {
creating_shape = false;
current_shape.resize(0);
workspace->update();
} else {
switch (edit_mode) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
case EDITMODE_REGION: {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
int t_id = get_current_tile();
if (workspace_mode == WORKSPACE_EDIT && t_id >= 0) {
undo_redo->create_action(TTR("Remove Tile"));
undo_redo->add_do_method(tileset.ptr(), "remove_tile", t_id);
_undo_tile_removal(t_id);
undo_redo->add_do_method(this, "_validate_current_tile_id");
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
Rect2 tile_region = tileset->tile_get_region(get_current_tile());
Size2 tile_workspace_size = tile_region.position + tile_region.size;
if (tile_workspace_size.x > get_current_texture()->get_size().x || tile_workspace_size.y > get_current_texture()->get_size().y) {
undo_redo->add_do_method(this, "update_workspace_minsize");
undo_redo->add_undo_method(this, "update_workspace_minsize");
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(workspace, "update");
undo_redo->add_undo_method(workspace, "update");
undo_redo->add_do_method(workspace_overlay, "update");
undo_redo->add_undo_method(workspace_overlay, "update");
undo_redo->commit_action();
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
update_workspace_tile_mode();
} break;
TileMap Fixes
2017-12-01 01:50:09 +01:00
case EDITMODE_COLLISION: {
if (!edited_collision_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
// Necessary to get the version that returns a Array instead of a Vector.
Array sd = tileset->call("tile_get_shapes", get_current_tile());
TileMap Fixes
2017-12-01 01:50:09 +01:00
for (int i = 0; i < sd.size(); i++) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (sd[i].get("shape") == edited_collision_shape) {
undo_redo->create_action(TTR("Remove Collision Polygon"));
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd.duplicate());
sd.remove(i);
undo_redo->add_do_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd);
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
break;
}
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
}
} break;
case EDITMODE_OCCLUSION: {
if (!edited_occlusion_shape.is_null()) {
undo_redo->create_action(TTR("Remove Occlusion Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
undo_redo->add_do_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), Ref<OccluderPolygon2D>());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), tileset->tile_get_light_occluder(get_current_tile()));
} else {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), tileset->autotile_get_light_occluder(get_current_tile(), edited_shape_coord), edited_shape_coord);
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
} break;
case EDITMODE_NAVIGATION: {
if (!edited_navigation_shape.is_null()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Remove Navigation Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
undo_redo->add_do_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), Ref<NavigationPolygon>());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), tileset->tile_get_navigation_polygon(get_current_tile()));
} else {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), Ref<NavigationPolygon>(), edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), tileset->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord), edited_shape_coord);
}
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
TileMap Fixes
2017-12-01 01:50:09 +01:00
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else if (p_tool == TOOL_SELECT) {
if (creating_shape) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
// Cancel Creation
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
creating_shape = false;
current_shape.resize(0);
workspace->update();
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_priority_changed(float val) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 03:42:23 +02:00
}
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
void TileSetEditor::_on_z_index_changed(float val) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 15:39:39 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::_on_grid_snap_toggled(bool p_val) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
helper->set_snap_options_visible(p_val);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Vector<Vector2> TileSetEditor::_get_collision_shape_points(const Ref<Shape2D> &p_shape) {
Ref<ConvexPolygonShape2D> convex = p_shape;
Ref<ConcavePolygonShape2D> concave = p_shape;
if (convex.is_valid()) {
return convex->get_points();
} else if (concave.is_valid()) {
Vector<Vector2> points;
for (int i = 0; i < concave->get_segments().size(); i += 2) {
points.push_back(concave->get_segments()[i]);
}
return points;
} else {
return Vector<Vector2>();
}
}
Vector<Vector2> TileSetEditor::_get_edited_shape_points() {
return _get_collision_shape_points(edited_collision_shape);
}
void TileSetEditor::_set_edited_shape_points(const Vector<Vector2> points) {
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 02:45:16 +01: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;
Vector2i cell_count = size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing));
for (int y = 0; y < cell_count.y; y++) {
for (int x = 0; x < cell_count.x; x++) {
SubtileData data;
Vector2i coord(x, y);
for (int i = 0; i < sd.size(); i++) {
if (sd[i].autotile_coord == coord) {
data.collisions.push_back(sd[i].shape);
}
}
data.navigation_shape = tileset->autotile_get_navigation_polygon(get_current_tile(), coord);
data.occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
current_tile_data[coord] = data;
}
}
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
void TileSetEditor::_update_toggle_shape_button() {
Ref<ConvexPolygonShape2D> convex = edited_collision_shape;
Ref<ConcavePolygonShape2D> concave = edited_collision_shape;
separator_shape_toggle->show();
tools[SHAPE_TOGGLE_TYPE]->show();
if (edit_mode != EDITMODE_COLLISION || !edited_collision_shape.is_valid()) {
separator_shape_toggle->hide();
tools[SHAPE_TOGGLE_TYPE]->hide();
} else if (concave.is_valid()) {
tools[SHAPE_TOGGLE_TYPE]->set_icon(get_icon("ConvexPolygonShape2D", "EditorIcons"));
tools[SHAPE_TOGGLE_TYPE]->set_text("Make Convex");
} else if (convex.is_valid()) {
tools[SHAPE_TOGGLE_TYPE]->set_icon(get_icon("ConcavePolygonShape2D", "EditorIcons"));
tools[SHAPE_TOGGLE_TYPE]->set_text("Make Concave");
} else {
// Shoudn't happen
separator_shape_toggle->hide();
tools[SHAPE_TOGGLE_TYPE]->hide();
}
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
void TileSetEditor::_select_next_tile() {
Array tiles = _get_tiles_in_current_texture(true);
if (tiles.size() == 0) {
set_current_tile(-1);
} else if (get_current_tile() == -1) {
set_current_tile(tiles[0]);
} else {
int index = tiles.find(get_current_tile());
if (index < 0) {
set_current_tile(tiles[0]);
} else if (index == tiles.size() - 1) {
set_current_tile(tiles[0]);
} else {
set_current_tile(tiles[index + 1]);
}
}
if (get_current_tile() == -1) {
return;
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
return;
} else {
switch (edit_mode) {
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
edited_shape_coord = Vector2();
_select_edited_shape_coord();
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
}
}
}
void TileSetEditor::_select_previous_tile() {
Array tiles = _get_tiles_in_current_texture(true);
if (tiles.size() == 0) {
set_current_tile(-1);
} else if (get_current_tile() == -1) {
set_current_tile(tiles[tiles.size() - 1]);
} else {
int index = tiles.find(get_current_tile());
if (index <= 0) {
set_current_tile(tiles[tiles.size() - 1]);
} else {
set_current_tile(tiles[index - 1]);
}
}
if (get_current_tile() == -1) {
return;
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
return;
} else {
switch (edit_mode) {
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
case EDITMODE_PRIORITY:
case EDITMODE_Z_INDEX: {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01: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-03-01 00:48:34 +01:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
Vector2i cell_count = size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
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 17:08:36 +02:00
default: {
}
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
}
}
}
Array TileSetEditor::_get_tiles_in_current_texture(bool sorted) {
Array a;
List<int> all_tiles;
if (!get_current_texture().is_valid()) {
return a;
}
tileset->get_tile_list(&all_tiles);
for (int i = 0; i < all_tiles.size(); i++) {
if (tileset->tile_get_texture(all_tiles[i]) == get_current_texture()) {
a.push_back(all_tiles[i]);
}
}
if (sorted) {
a.sort_custom(this, "_sort_tiles");
}
return a;
}
bool TileSetEditor::_sort_tiles(Variant p_a, Variant p_b) {
int a = p_a;
int b = p_b;
Vector2 pos_a = tileset->tile_get_region(a).position;
Vector2 pos_b = tileset->tile_get_region(b).position;
if (pos_a.y < pos_b.y) {
return true;
} else if (pos_a.y == pos_b.y) {
if (pos_a.x < pos_b.x) {
return true;
} else {
return false;
}
} 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 02:45:16 +01: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-03-01 00:48:34 +01:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
Vector2i cell_count = size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
if (edited_shape_coord.x >= 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 02:45:16 +01: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-03-01 00:48:34 +01:00
Vector2 size = tileset->tile_get_region(get_current_tile()).size;
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
Vector2i cell_count = size / (tileset->autotile_get_size(get_current_tile()) + Vector2(spacing, spacing));
Allow to change selection around all tiles on the texture without clicking on them. Fixes #25203. Fixes #22077
2019-03-01 00:48:34 +01:00
if (edited_shape_coord.x <= 0 && edited_shape_coord.y <= 0) {
_select_previous_tile();
} else {
edited_shape_coord.x--;
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 02:45:16 +01:00
void TileSetEditor::_select_next_shape() {
if (get_current_tile() == -1) {
_select_next_subtile();
} else if (edit_mode != EDITMODE_COLLISION) {
_select_next_subtile();
} else {
Vector2i edited_coord = Vector2();
if (tileset->tile_get_tile_mode(get_current_tile()) != TileSet::SINGLE_TILE) {
edited_coord = edited_shape_coord;
}
SubtileData data = current_tile_data[edited_coord];
if (data.collisions.size() == 0) {
_select_next_subtile();
} else {
int index = data.collisions.find(edited_collision_shape);
if (index < 0) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[0]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
} else if (index == data.collisions.size() - 1) {
_select_next_subtile();
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[index + 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
current_shape.resize(0);
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
current_tile_region.position += shape_anchor;
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
}
void TileSetEditor::_select_previous_shape() {
if (get_current_tile() == -1) {
_select_previous_subtile();
if (get_current_tile() != -1 && edit_mode == EDITMODE_COLLISION) {
SubtileData data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
return;
}
} else if (edit_mode != EDITMODE_COLLISION) {
_select_previous_subtile();
} else {
Vector2i edited_coord = Vector2();
if (tileset->tile_get_tile_mode(get_current_tile()) != TileSet::SINGLE_TILE) {
edited_coord = edited_shape_coord;
}
SubtileData data = current_tile_data[edited_coord];
if (data.collisions.size() == 0) {
_select_previous_subtile();
data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
int index = data.collisions.find(edited_collision_shape);
if (index < 0) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
} else if (index == 0) {
_select_previous_subtile();
data = current_tile_data[Vector2i(edited_shape_coord)];
if (data.collisions.size() > 1) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[data.collisions.size() - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(data.collisions[index - 1]);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
current_shape.resize(0);
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = edited_shape_coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
current_tile_region.position += shape_anchor;
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
}
}
workspace->update();
workspace_container->update();
helper->_change_notify("");
}
}
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
void TileSetEditor::_set_edited_collision_shape(const Ref<Shape2D> &p_shape) {
edited_collision_shape = p_shape;
_update_toggle_shape_button();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_step(Vector2 p_val) {
snap_step.x = CLAMP(p_val.x, 0, 256);
snap_step.y = CLAMP(p_val.y, 0, 256);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_off(Vector2 p_val) {
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 06:57:37 +01:00
workspace->update();
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::_set_snap_sep(Vector2 p_val) {
snap_separation.x = CLAMP(p_val.x, 0, 256);
snap_separation.y = CLAMP(p_val.y, 0, 256);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->update();
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
void TileSetEditor::_validate_current_tile_id() {
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 19:28:42 +02:00
Map<Vector2, uint32_t> bitmask_map = tileset->autotile_get_bitmask_map(p_id);
for (Map<Vector2, uint32_t>::Element *E = bitmask_map.front(); E; E = E->next()) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask", p_id, E->key(), E->value());
}
Map<Vector2, int> priority_map = tileset->autotile_get_priority_map(p_id);
for (Map<Vector2, int>::Element *E = priority_map.front(); E; E = E->next()) {
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_subtile_priority", p_id, E->key(), E->value());
}
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_icon_coordinate", p_id, tileset->autotile_get_icon_coordinate(p_id));
Map<Vector2, int> z_map = tileset->autotile_get_z_index_map(p_id);
for (Map<Vector2, int>::Element *E = z_map.front(); E; E = E->next()) {
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_z_index", p_id, E->key(), E->value());
}
undo_redo->add_undo_method(tileset.ptr(), "tile_set_tile_mode", p_id, tileset->tile_get_tile_mode(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_size", p_id, tileset->autotile_get_size(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_spacing", p_id, tileset->autotile_get_spacing(p_id));
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_bitmask_mode", p_id, tileset->autotile_get_bitmask_mode(p_id));
}
}
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
void TileSetEditor::_zoom_in() {
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 05:38:26 +01:00
void TileSetEditor::_zoom_reset() {
support New TileSet Editor zooming use CTRL/CMD + MouseWheel fixed code style for clang-format apply clang-format
2018-10-21 15:56:05 +02:00
workspace->set_scale(Vector2(1, 1));
workspace_container->set_custom_minimum_size(workspace->get_rect().size);
workspace_overlay->set_custom_minimum_size(workspace->get_rect().size);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::draw_highlight_current_tile() {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
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 23:54:12 +02:00
} else {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
workspace->draw_rect(Rect2(Point2(0, 0), workspace->get_rect().size), shadow_color);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::draw_highlight_subtile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color shadow_color = Color(0.3, 0.3, 0.3, 0.3);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 size = tileset->autotile_get_size(get_current_tile());
int spacing = tileset->autotile_get_spacing(get_current_tile());
Rect2 region = tileset->tile_get_region(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
coord += region.position;
coord += WORKSPACE_MARGIN;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
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 01:07:43 +01:00
coord += Vector2(1, 1) / workspace->get_scale().x;
workspace->draw_rect(Rect2(coord, size - Vector2(2, 2) / workspace->get_scale().x), Color(1, 0, 0), false);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < other_highlighted.size(); i++) {
coord = other_highlighted[i];
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
coord += region.position;
coord += WORKSPACE_MARGIN;
TileSetEditorPlugin: take scale in accout when highlighting current selected subtile.
2018-01-18 01:07:43 +01:00
coord += Vector2(1, 1) / workspace->get_scale().x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->draw_rect(Rect2(coord, size - Vector2(2, 2) / workspace->get_scale().x), Color(1, 0.5, 0.5), false);
}
}
void TileSetEditor::draw_tile_subdivision(int p_id, Color p_color) const {
Color c = p_color;
if (tileset->tile_get_tile_mode(p_id) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(p_id) == TileSet::ATLAS_TILE) {
Rect2 region = tileset->tile_get_region(p_id);
Size2 size = tileset->autotile_get_size(p_id);
int spacing = tileset->autotile_get_spacing(p_id);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
float j = size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.x) {
if (spacing <= 0) {
workspace->draw_line(region.position + WORKSPACE_MARGIN + Point2(j, 0), region.position + WORKSPACE_MARGIN + Point2(j, region.size.y), c);
} else {
workspace->draw_rect(Rect2(region.position + WORKSPACE_MARGIN + Point2(j, 0), Size2(spacing, region.size.y)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j = size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.y) {
if (spacing <= 0) {
workspace->draw_line(region.position + WORKSPACE_MARGIN + Point2(0, j), region.position + WORKSPACE_MARGIN + Point2(region.size.x, j), c);
} else {
workspace->draw_rect(Rect2(region.position + WORKSPACE_MARGIN + Point2(0, j), Size2(region.size.x, spacing)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
}
void TileSetEditor::draw_edited_region_subdivision() const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color c = Color(0.3, 0.7, 0.6);
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 region = edited_region;
Size2 size;
int spacing;
bool draw;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode == WORKSPACE_EDIT) {
int p_id = get_current_tile();
size = tileset->autotile_get_size(p_id);
spacing = tileset->autotile_get_spacing(p_id);
draw = tileset->tile_get_tile_mode(p_id) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(p_id) == TileSet::ATLAS_TILE;
} else {
size = snap_step;
spacing = snap_separation.x;
draw = workspace_mode != WORKSPACE_CREATE_SINGLE;
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (draw) {
float j = size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.x) {
if (spacing <= 0) {
workspace->draw_line(region.position + Point2(j, 0), region.position + Point2(j, region.size.y), c);
} else {
workspace->draw_rect(Rect2(region.position + Point2(j, 0), Size2(spacing, region.size.y)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.x;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j = size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
while (j < region.size.y) {
if (spacing <= 0) {
workspace->draw_line(region.position + Point2(0, j), region.position + Point2(region.size.x, j), c);
} else {
workspace->draw_rect(Rect2(region.position + Point2(0, j), Size2(region.size.x, spacing)), c);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
j += spacing + size.y;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::draw_grid_snap() {
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Color grid_color = Color(0.4, 0, 1);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
Size2 s = workspace->get_size();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
int width_count = Math::floor((s.width - WORKSPACE_MARGIN.x) / (snap_step.x + snap_separation.x));
int height_count = Math::floor((s.height - WORKSPACE_MARGIN.y) / (snap_step.y + snap_separation.y));
Autotile Enhancement
2017-12-28 06:57:37 +01:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
int last_p = 0;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (snap_step.x != 0) {
for (int i = 0; i <= width_count; i++) {
if (i == 0 && snap_offset.x != 0) {
last_p = snap_offset.x;
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (snap_separation.x != 0) {
if (i != 0) {
workspace->draw_rect(Rect2(last_p, 0, snap_separation.x, s.height), grid_color);
last_p += snap_separation.x;
} else {
workspace->draw_rect(Rect2(last_p, 0, -snap_separation.x, s.height), grid_color);
}
} else {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->draw_line(Point2(last_p, 0), Point2(last_p, s.height), grid_color);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
last_p += snap_step.x;
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
last_p = 0;
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (snap_step.y != 0) {
for (int i = 0; i <= height_count; i++) {
if (i == 0 && snap_offset.y != 0) {
last_p = snap_offset.y;
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (snap_separation.x != 0) {
if (i != 0) {
workspace->draw_rect(Rect2(0, last_p, s.width, snap_separation.y), grid_color);
last_p += snap_separation.y;
} else {
workspace->draw_rect(Rect2(0, last_p, s.width, -snap_separation.y), grid_color);
}
} else {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
workspace->draw_line(Point2(0, last_p), Point2(s.width, last_p), grid_color);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Autotile Enhancement
2017-12-28 06:57:37 +01:00
last_p += snap_step.y;
}
}
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::draw_polygon_shapes() {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
int t_id = get_current_tile();
if (t_id < 0)
return;
switch (edit_mode) {
case EDITMODE_COLLISION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(t_id);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int i = 0; i < sd.size(); i++) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 coord = Vector2(0, 0);
Vector2 anchor = Vector2(0, 0);
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
coord = sd[i].autotile_coord;
anchor = tileset->autotile_get_size(t_id);
anchor.x += tileset->autotile_get_spacing(t_id);
anchor.y += tileset->autotile_get_spacing(t_id);
anchor.x *= coord.x;
anchor.y *= coord.y;
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Ref<Shape2D> shape = sd[i].shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Color c_bg;
Color c_border;
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Ref<ConvexPolygonShape2D> convex = shape;
bool is_convex = convex.is_valid();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if ((tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE || coord == edited_shape_coord) && sd[i].shape == edited_collision_shape) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
if (is_convex) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.8, 0, 1, 0.5);
c_border = Color(0.8, 0, 1);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
if (is_convex) {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
} else {
c_bg = Color(0.9, 0.45, 0.075, 0.5);
c_border = Color(0.9, 0.45, 0.075);
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_collision_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int j = 0; j < _get_collision_shape_points(shape).size(); j++) {
polygon.push_back(_get_collision_shape_points(shape)[j] + anchor);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
colors.push_back(c_bg);
}
}
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 16:45:18 +02:00
if (polygon.size() < 3)
Update tile_set_editor_plugin.cpp
2019-03-27 18:20:52 +01:00
continue;
Fix crash when using the Tileset Editor when the given shape has no points
2019-04-02 16:45:18 +02:00
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 03:42:23 +02:00
}
if (shape == edited_collision_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
} break;
case EDITMODE_OCCLUSION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Ref<OccluderPolygon2D> shape = edited_occlusion_shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> polygon;
Vector<Color> colors;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
Vector2 anchor = WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(get_current_tile()).position;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
for (int j = 0; j < shape->get_polygon().size(); j++) {
polygon.push_back(shape->get_polygon()[j] + anchor);
colors.push_back(c_bg);
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape) {
TileSetEditor: Don't draw invalid occlusion shapes. Fixes #24238
2019-03-06 19:31:16 +01: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 17:20:49 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
} else {
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 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Ref<OccluderPolygon2D> shape = E->value();
if (shape.is_valid()) {
Color c_bg;
Color c_border;
if (coord == edited_shape_coord && shape == edited_occlusion_shape) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_occlusion_shape && current_shape.size() > 2) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (int j = 0; j < current_shape.size(); j++) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
for (int j = 0; j < shape->get_polygon().size(); j++) {
polygon.push_back(shape->get_polygon()[j] + anchor);
colors.push_back(c_bg);
}
}
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 12:08:44 +01:00
}
if (shape == edited_occlusion_shape) {
TileSetEditorPlgn: use EditorHandle icon as handle
2018-03-02 12:36:18 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
}
} break;
case EDITMODE_NAVIGATION: {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Ref<NavigationPolygon> shape = edited_navigation_shape;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
if (shape.is_valid()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Color c_bg = Color(0, 1, 1, 0.5);
Color c_border = Color(0, 1, 1);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector<Vector2> polygon;
Vector<Color> colors;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
Vector2 anchor = WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(get_current_tile()).position;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
} else {
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 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 17:35:12 +01:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
} else {
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 23:54:12 +02:00
anchor += WORKSPACE_MARGIN;
anchor += tileset->tile_get_region(t_id).position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Ref<NavigationPolygon> shape = E->value();
if (shape.is_valid()) {
Color c_bg;
Color c_border;
if (coord == edited_shape_coord && shape == edited_navigation_shape) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
c_bg = Color(0.9, 0.7, 0.07, 0.5);
c_border = Color(0.9, 0.7, 0.07, 1);
}
Vector<Vector2> polygon;
Vector<Color> colors;
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
if (!creating_shape && shape == edited_navigation_shape && current_shape.size() > 2) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
for (int j = 0; j < current_shape.size(); j++) {
polygon.push_back(current_shape[j]);
colors.push_back(c_bg);
}
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
} else {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
PoolVector<Vector2> vertices = shape->get_vertices();
Tileset Editor Improvement
2018-02-17 12:08:44 +01: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 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
workspace->draw_polygon(polygon, colors);
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (coord == edited_shape_coord) {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 17:35:12 +01:00
}
if (shape == edited_navigation_shape) {
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
}
}
}
} break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 17:08:36 +02:00
default: {
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
General fixes for the TileSet editor
2018-12-24 17:35:12 +01:00
Implement auto-tiling
2017-10-22 03:42:23 +02: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 17:20:49 +01:00
draw_handles = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::close_shape(const Vector2 &shape_anchor) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
creating_shape = false;
if (edit_mode == EDITMODE_COLLISION) {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
if (current_shape.size() >= 3) {
Ref<ConvexPolygonShape2D> shape = memnew(ConvexPolygonShape2D);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
Vector<Vector2> points;
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
float p_total = 0;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Autotile Enhancement
2017-12-28 06:57:37 +01:00
for (int i = 0; i < current_shape.size(); i++) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
points.push_back(current_shape[i] - shape_anchor);
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
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 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
if (p_total < 0)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
points.invert();
Improve : ease of use TileSet Editor
2017-12-30 06:34:33 +01:00
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
shape->set_points(points);
Autotile Enhancement
2017-12-28 06:57:37 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Collision Polygon"));
// Necessary to get the version that returns a Array instead of a Vector.
Array sd = tileset->call("tile_get_shapes", get_current_tile());
undo_redo->add_undo_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd.duplicate());
for (int i = 0; i < sd.size(); i++) {
if (sd[i].get("shape") == edited_collision_shape) {
sd.remove(i);
break;
}
}
undo_redo->add_do_method(tileset.ptr(), "tile_set_shapes", get_current_tile(), sd);
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE)
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(tileset.ptr(), "tile_add_shape", get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
else
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
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 06:57:37 +01:00
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
Ref<OccluderPolygon2D> shape = memnew(OccluderPolygon2D);
PoolVector<Vector2> polygon;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
}
w = PoolVector<Vector2>::Write();
shape->set_polygon(polygon);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Occlusion Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), shape, edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_light_occluder", get_current_tile(), tileset->autotile_get_light_occluder(get_current_tile(), edited_shape_coord), edited_shape_coord);
} else {
undo_redo->add_do_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), shape);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_light_occluder", get_current_tile(), tileset->tile_get_light_occluder(get_current_tile()));
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
} else if (edit_mode == EDITMODE_NAVIGATION) {
Ref<NavigationPolygon> shape = memnew(NavigationPolygon);
PoolVector<Vector2> polygon;
Vector<int> indices;
polygon.resize(current_shape.size());
PoolVector<Vector2>::Write w = polygon.write();
for (int i = 0; i < current_shape.size(); i++) {
w[i] = current_shape[i] - shape_anchor;
indices.push_back(i);
}
w = PoolVector<Vector2>::Write();
shape->set_vertices(polygon);
shape->add_polygon(indices);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->create_action(TTR("Create Navigation Polygon"));
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
undo_redo->add_do_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), shape, edited_shape_coord);
undo_redo->add_undo_method(tileset.ptr(), "autotile_set_navigation_polygon", get_current_tile(), tileset->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord), edited_shape_coord);
} else {
undo_redo->add_do_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), shape);
undo_redo->add_undo_method(tileset.ptr(), "tile_set_navigation_polygon", get_current_tile(), tileset->tile_get_navigation_polygon(get_current_tile()));
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
tools[TOOL_SELECT]->set_pressed(true);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
undo_redo->add_do_method(this, "_select_edited_shape_coord");
undo_redo->add_undo_method(this, "_select_edited_shape_coord");
undo_redo->commit_action();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->_change_notify("");
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
void TileSetEditor::select_coord(const Vector2 &coord) {
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
_update_tile_data();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
current_shape = PoolVector2Array();
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
if (get_current_tile() == -1)
return;
New TileSet Editor
2018-07-29 23:54:12 +02:00
Rect2 current_tile_region = tileset->tile_get_region(get_current_tile());
current_tile_region.position += WORKSPACE_MARGIN;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
if (edited_collision_shape != tileset->tile_get_shape(get_current_tile(), 0))
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(tileset->tile_get_shape(get_current_tile(), 0));
Tileset Editor Improvement
2018-02-17 12:08:44 +01: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 22:50:19 +01:00
for (int i = 0; i < _get_edited_shape_points().size(); i++) {
current_shape.push_back(_get_edited_shape_points()[i] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else if (edit_mode == EDITMODE_OCCLUSION) {
current_shape.resize(0);
if (edited_occlusion_shape.is_valid()) {
for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
} else if (edit_mode == EDITMODE_NAVIGATION) {
current_shape.resize(0);
if (edited_navigation_shape.is_valid()) {
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 23:54:12 +02:00
current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]] + current_tile_region.position);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(get_current_tile());
bool found_collision_shape = false;
for (int i = 0; i < sd.size(); i++) {
if (sd[i].autotile_coord == coord) {
if (edited_collision_shape != sd[i].shape)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(sd[i].shape);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
found_collision_shape = true;
break;
}
}
if (!found_collision_shape)
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
_set_edited_collision_shape(Ref<ConvexPolygonShape2D>(NULL));
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01: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 12:08:44 +01:00
int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 size = tileset->autotile_get_size(get_current_tile());
Vector2 shape_anchor = coord;
shape_anchor.x *= (size.x + spacing);
shape_anchor.y *= (size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
shape_anchor += current_tile_region.position;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (edit_mode == EDITMODE_COLLISION) {
current_shape.resize(0);
if (edited_collision_shape.is_valid()) {
TileSetEditor: Allow to toggle Convex/Concave collisions. Alternative fix to #24003
2019-03-02 22:50:19 +01:00
for (int j = 0; j < _get_edited_shape_points().size(); j++) {
current_shape.push_back(_get_edited_shape_points()[j] + shape_anchor);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
} else if (edit_mode == EDITMODE_OCCLUSION) {
current_shape.resize(0);
if (edited_occlusion_shape.is_valid()) {
for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + shape_anchor);
}
}
} else if (edit_mode == EDITMODE_NAVIGATION) {
current_shape.resize(0);
if (edited_navigation_shape.is_valid()) {
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 11:53:30 +01:00
}
}
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
workspace->update();
workspace_container->update();
helper->_change_notify("");
Fixing weird behaviour on autotile editor
2018-01-05 11:53:30 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 TileSetEditor::snap_point(const Vector2 &point) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 p = point;
Vector2 coord = edited_shape_coord;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
Vector2 tile_size = tileset->autotile_get_size(get_current_tile());
int spacing = tileset->autotile_get_spacing(get_current_tile());
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Vector2 anchor = coord;
anchor.x *= (tile_size.x + spacing);
anchor.y *= (tile_size.y + spacing);
New TileSet Editor
2018-07-29 23:54:12 +02:00
anchor += tileset->tile_get_region(get_current_tile()).position;
anchor += WORKSPACE_MARGIN;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Rect2 region(anchor, tile_size);
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
region.position = tileset->tile_get_region(get_current_tile()).position + WORKSPACE_MARGIN;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
region.size = tileset->tile_get_region(get_current_tile()).size;
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
Autotile Enhancement
2017-12-28 06:57:37 +01:00
p.x = Math::snap_scalar_seperation(snap_offset.x, snap_step.x, p.x, snap_separation.x);
p.y = Math::snap_scalar_seperation(snap_offset.y, snap_step.y, p.y, snap_separation.y);
}
Implement auto-tiling
2017-10-22 03:42:23 +02: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 17:20:49 +01: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 23:54:12 +02:00
void TileSetEditor::update_texture_list() {
Ref<Texture> selected_texture = get_current_texture();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
helper->set_tileset(tileset);
Implement auto-tiling
2017-10-22 03:42:23 +02:00
List<int> ids;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset->get_tile_list(&ids);
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
Vector<int> ids_to_remove;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
// Clear tiles referencing gone textures (user has been already given the chance to fix broken deps)
if (!tileset->tile_get_texture(E->get()).is_valid()) {
ids_to_remove.push_back(E->get());
ERR_CONTINUE(!tileset->tile_get_texture(E->get()).is_valid());
}
New TileSet Editor
2018-07-29 23:54:12 +02: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 17:20:49 +01:00
add_texture(tileset->tile_get_texture(E->get()));
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
}
Let TileSet editor sanitize out tiles with wrong textures
2018-11-02 04:54:28 +01:00
for (int i = 0; i < ids_to_remove.size(); i++) {
tileset->remove_tile(ids_to_remove[i]);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (texture_list->get_item_count() > 0 && selected_texture.is_valid()) {
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 17:20:49 +01:00
_validate_current_tile_id();
New TileSet Editor
2018-07-29 23:54:12 +02:00
_on_texture_list_selected(-1);
Add undo-redo to the TileSet editor, and other improvements
2018-12-19 17:20:49 +01:00
workspace_overlay->update();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
update_texture_list_icon();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
helper->_change_notify("");
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::update_texture_list_icon() {
for (int current_idx = 0; current_idx < texture_list->get_item_count(); current_idx++) {
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 03:35:49 +01: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 12:08:44 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
texture_list->update();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditor::update_workspace_tile_mode() {
New TileSet Editor
2018-07-29 23:54:12 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
if (!get_current_texture().is_valid()) {
tool_workspacemode[WORKSPACE_EDIT]->set_pressed(true);
workspace_mode = WORKSPACE_EDIT;
for (int i = 1; i < WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i]->set_disabled(true);
}
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_disabled(true);
tools[SELECT_PREVIOUS]->set_disabled(true);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
} else {
for (int i = 1; i < WORKSPACE_MODE_MAX; i++) {
tool_workspacemode[i]->set_disabled(false);
}
Disable coord navigation buttons in TileSet editor when no texture is selected
2019-03-05 15:22:44 +01:00
tools[SELECT_NEXT]->set_disabled(false);
tools[SELECT_PREVIOUS]->set_disabled(false);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (workspace_mode != WORKSPACE_EDIT) {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
tool_editmode[EDITMODE_REGION]->show();
tool_editmode[EDITMODE_REGION]->set_pressed(true);
_on_edit_mode_changed(EDITMODE_REGION);
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
return;
}
if (get_current_tile() < 0) {
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->hide();
}
Allow to change selection of collision shapes added to the same tile. Fixes #26369.
2019-03-01 02:45:16 +01:00
for (int i = TOOL_SELECT; i < ZOOM_OUT; i++) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tools[i]->hide();
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->hide();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
separator_bitmask->hide();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_delete->hide();
separator_grid->hide();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
return;
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
for (int i = 0; i < EDITMODE_MAX; i++) {
tool_editmode[i]->show();
}
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
separator_editmode->show();
New TileSet Editor
2018-07-29 23:54:12 +02:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
if (tool_editmode[EDITMODE_ICON]->is_pressed() || tool_editmode[EDITMODE_PRIORITY]->is_pressed() || tool_editmode[EDITMODE_BITMASK]->is_pressed() || tool_editmode[EDITMODE_Z_INDEX]->is_pressed()) {
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
New TileSet Editor
2018-07-29 23:54:12 +02:00
edit_mode = EDITMODE_COLLISION;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
select_coord(Vector2(0, 0));
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tool_editmode[EDITMODE_ICON]->hide();
tool_editmode[EDITMODE_BITMASK]->hide();
tool_editmode[EDITMODE_PRIORITY]->hide();
Add Z-Index for Autotile
2018-07-02 15:39:39 +02:00
tool_editmode[EDITMODE_Z_INDEX]->hide();
Fixes for TileSetEditor and TileMapEditor [TileSetEditor] Hide Bitmask and Priority for ATLAS_TILE [TileMapEditor] Hide "Disable autotile" if the selected tile isn't autotile Fix #22756, don't update bitmask when tilemode is ATLAS_TILE
2018-12-20 18:17:52 +01:00
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
New TileSet Editor
2018-07-29 23:54:12 +02: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 17:20:49 +01:00
_select_edited_shape_coord();
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::ATLAS_TILE) {
if (tool_editmode[EDITMODE_PRIORITY]->is_pressed() || tool_editmode[EDITMODE_BITMASK]->is_pressed()) {
tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
edit_mode = EDITMODE_COLLISION;
}
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 17:20:49 +01:00
_select_edited_shape_coord();
New TileSet Editor
2018-07-29 23:54:12 +02:00
tool_editmode[EDITMODE_BITMASK]->hide();
tool_editmode[EDITMODE_PRIORITY]->hide();
}
_on_edit_mode_changed(edit_mode);
}
Make TileSet editor's workspace change size according to region changes
2019-02-28 02:09:11 +01:00
void TileSetEditor::update_workspace_minsize() {
Size2 workspace_min_size = get_current_texture()->get_size();
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()) {
if (tileset->tile_get_texture(E->get())->get_rid() == current_texture_rid) {
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;
}
}
workspace->set_custom_minimum_size(workspace_min_size + WORKSPACE_MARGIN * 2);
workspace_container->set_custom_minimum_size(workspace_min_size + WORKSPACE_MARGIN * 2);
workspace_overlay->set_custom_minimum_size(workspace_min_size + WORKSPACE_MARGIN * 2);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TileSetEditor::update_edited_region(const Vector2 &end_point) {
edited_region = Rect2(region_from, Size2());
if (tools[TOOL_GRID_SNAP]->is_pressed()) {
Vector2 grid_coord;
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
grid_coord = ((region_from - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 23:54:12 +02:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 16:36:51 +01:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(grid_coord);
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
grid_coord = ((end_point - snap_offset) / (snap_step + snap_separation)).floor();
grid_coord *= (snap_step + snap_separation);
New TileSet Editor
2018-07-29 23:54:12 +02:00
grid_coord += snap_offset;
edited_region.expand_to(grid_coord);
Fix incorrect grid snapping in TileSet editor with separation
2018-12-31 16:36:51 +01:00
grid_coord += snap_step;
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(grid_coord);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
New TileSet Editor
2018-07-29 23:54:12 +02:00
edited_region.expand_to(end_point);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
int TileSetEditor::get_current_tile() const {
return current_tile;
}
void TileSetEditor::set_current_tile(int p_id) {
if (current_tile != p_id) {
current_tile = p_id;
helper->_change_notify("");
select_coord(Vector2(0, 0));
update_workspace_tile_mode();
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (p_id == -1) {
editor->get_inspector()->edit(tileset.ptr());
} else {
editor->get_inspector()->edit(helper);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
}
Ref<Texture> TileSetEditor::get_current_texture() {
if (texture_list->get_selected_items().size() == 0)
return Ref<Texture>();
Implement auto-tiling
2017-10-22 03:42:23 +02:00
else
New TileSet Editor
2018-07-29 23:54:12 +02:00
return texture_map[texture_list->get_item_metadata(texture_list->get_selected_items()[0])];
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::set_tileset(const Ref<TileSet> &p_tileset) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset = p_tileset;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::set_snap_options_visible(bool p_visible) {
snap_options_visible = p_visible;
_change_notify("");
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool TilesetEditorContext::_set(const StringName &p_name, const Variant &p_value) {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
String name = p_name.operator String();
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (name == "options_offset") {
Vector2 snap = p_value;
tileset_editor->_set_snap_off(snap + WORKSPACE_MARGIN);
return true;
} else if (name == "options_step") {
Vector2 snap = p_value;
tileset_editor->_set_snap_step(snap);
return true;
} else if (name == "options_separation") {
Vector2 snap = p_value;
tileset_editor->_set_snap_sep(snap);
return true;
} else if (p_name.operator String().left(5) == "tile_") {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
String name2 = p_name.operator String().right(5);
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool v = false;
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 21:10:08 +01:00
if (name2 == "autotile_bitmask_mode") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/bitmask_mode", p_value, &v);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
} else if (name2 == "subtile_size") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/tile_size", p_value, &v);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
} else if (name2 == "subtile_spacing") {
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/autotile/spacing", p_value, &v);
} else {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
tileset->set(String::num(tileset_editor->get_current_tile(), 0) + "/" + name2, p_value, &v);
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
if (v) {
tileset->_change_notify("");
tileset_editor->workspace->update();
tileset_editor->workspace_overlay->update();
}
return v;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
} else if (name == "tileset_script") {
tileset->set_script(p_value);
return true;
TileSetEditor: Expose to the user OneWayCollision+Margin properties. Fixes #25817.
2019-03-04 04:22:10 +01:00
} else if (name == "selected_collision_one_way") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
tileset->tile_set_shape_one_way(tileset_editor->get_current_tile(), index, p_value);
return true;
}
}
return false;
} else if (name == "selected_collision_one_way_margin") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
tileset->tile_set_shape_one_way_margin(tileset_editor->get_current_tile(), index, p_value);
return true;
}
}
return false;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_editor->err_dialog->set_text(TTR("This property can't be changed."));
tileset_editor->err_dialog->popup_centered(Size2(300, 60));
return false;
}
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02:00
bool TilesetEditorContext::_get(const StringName &p_name, Variant &r_ret) const {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
String name = p_name.operator String();
Fix method not returning value in all paths (autotile editor)
2017-12-17 19:03:46 +01:00
bool v = false;
New TileSet Editor
2018-07-29 23:54:12 +02:00
if (name == "options_offset") {
r_ret = tileset_editor->snap_offset - WORKSPACE_MARGIN;
v = true;
} else if (name == "options_step") {
r_ret = tileset_editor->snap_step;
v = true;
} else if (name == "options_separation") {
r_ret = tileset_editor->snap_separation;
v = true;
} else if (name.left(5) == "tile_") {
name = name.right(5);
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 04:22:10 +01:00
} else if (name == "selected_collision_one_way") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
r_ret = sd[index].one_way_collision;
v = true;
break;
}
}
} else if (name == "selected_collision_one_way_margin") {
Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(tileset_editor->get_current_tile());
for (int index = 0; index < sd.size(); index++) {
if (sd[index].shape == tileset_editor->edited_collision_shape) {
r_ret = sd[index].one_way_collision_margin;
v = true;
break;
}
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
} else if (name == "selected_navigation") {
r_ret = tileset_editor->edited_navigation_shape;
v = true;
} else if (name == "selected_occlusion") {
r_ret = tileset_editor->edited_occlusion_shape;
v = true;
TileSet editor Fixes Properly draw navigation and oclusion polygons for SINGLE type tiles. Fixes #21398 Add some checks for TileID validation before accessing to it's properties. Fixes #21397 Fix 'Keep inside region' snap option for tiles with SINGLE_TILE mode. Fixes #21402 Restore hability to asign/unasign an script to a tileset. Fixes #20886
2018-08-26 22:10:01 +02:00
} else if (name == "tileset_script") {
r_ret = tileset->get_script();
v = true;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
Fix method not returning value in all paths (autotile editor)
2017-12-17 19:03:46 +01:00
return v;
Implement auto-tiling
2017-10-22 03:42:23 +02:00
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
void TilesetEditorContext::_get_property_list(List<PropertyInfo> *p_list) const {
Implement auto-tiling
2017-10-22 03:42:23 +02:00
New TileSet Editor
2018-07-29 23:54:12 +02: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 04:22:10 +01: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 23:54:12 +02: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 22:10:01 +02: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 03:42:23 +02:00
}
Hide "Script" section in the "TilesetEditorContext"
2018-12-07 05:18:02 +01:00
void TilesetEditorContext::_bind_methods() {
ClassDB::bind_method("_hide_script_from_inspector", &TilesetEditorContext::_hide_script_from_inspector);
}
New TileSet Editor
2018-07-29 23:54:12 +02:00
TilesetEditorContext::TilesetEditorContext(TileSetEditor *p_tileset_editor) {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor = p_tileset_editor;
Added a workaround to avoid crashes due to how TileSet editor works, fixes #23672 Also fixed a few uninitialized memory variables.
2019-02-22 21:42:29 +01:00
snap_options_visible = false;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditorPlugin::edit(Object *p_node) {
if (Object::cast_to<TileSet>(p_node)) {
tileset_editor->edit(Object::cast_to<TileSet>(p_node));
New TileSet Editor
2018-07-29 23:54:12 +02:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
bool TileSetEditorPlugin::handles(Object *p_node) const {
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
return p_node->is_class("TileSet") || p_node->is_class("TilesetEditorContext");
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
void TileSetEditorPlugin::make_visible(bool p_visible) {
if (p_visible) {
tileset_editor_button->show();
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
editor->make_bottom_panel_item_visible(tileset_editor);
New TileSet Editor
2018-07-29 23:54:12 +02:00
get_tree()->connect("idle_frame", tileset_editor, "_on_workspace_process");
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
} else {
Changes to the TileSet and TextureRegion editors
2018-08-13 01:24:20 +02:00
editor->hide_bottom_panel();
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor_button->hide();
New TileSet Editor
2018-07-29 23:54:12 +02:00
get_tree()->disconnect("idle_frame", tileset_editor, "_on_workspace_process");
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
}
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
Dictionary TileSetEditorPlugin::get_state() const {
Dictionary state;
state["snap_offset"] = tileset_editor->snap_offset;
state["snap_step"] = tileset_editor->snap_step;
state["snap_separation"] = tileset_editor->snap_separation;
state["snap_enabled"] = tileset_editor->tools[TileSetEditor::TOOL_GRID_SNAP]->is_pressed();
state["keep_inside_tile"] = tileset_editor->tools[TileSetEditor::SHAPE_KEEP_INSIDE_TILE]->is_pressed();
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
state["show_information"] = tileset_editor->tools[TileSetEditor::VISIBLE_INFO]->is_pressed();
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
return state;
}
void TileSetEditorPlugin::set_state(const Dictionary &p_state) {
Dictionary state = p_state;
if (state.has("snap_step")) {
tileset_editor->_set_snap_step(state["snap_step"]);
}
if (state.has("snap_offset")) {
tileset_editor->_set_snap_off(state["snap_offset"]);
}
if (state.has("snap_separation")) {
tileset_editor->_set_snap_sep(state["snap_separation"]);
}
if (state.has("snap_enabled")) {
tileset_editor->tools[TileSetEditor::TOOL_GRID_SNAP]->set_pressed(state["snap_enabled"]);
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (tileset_editor->helper) {
tileset_editor->_on_grid_snap_toggled(state["snap_enabled"]);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
if (state.has("keep_inside_tile")) {
tileset_editor->tools[TileSetEditor::SHAPE_KEEP_INSIDE_TILE]->set_pressed(state["keep_inside_tile"]);
}
TileSetEditor: Show Edition Context by demand
2019-02-23 04:04:31 +01:00
if (state.has("show_information")) {
tileset_editor->tools[TileSetEditor::VISIBLE_INFO]->set_pressed(state["show_information"]);
}
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
}
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) {
New TileSet Editor
2018-07-29 23:54:12 +02:00
editor = p_node;
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor = memnew(TileSetEditor(p_node));
New TileSet Editor
2018-07-29 23:54:12 +02:00
tileset_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
tileset_editor->hide();
Add option to move Tile/GridMap editors to another side
2018-08-21 06:35:48 +02:00
General enhancements to the Polygon2D, TextureRegion, and TileSet editors
2018-11-24 05:38:26 +01:00
tileset_editor_button = p_node->add_bottom_panel_item(TTR("TileSet"), tileset_editor);
Tileset Editor Improvement
2018-02-17 12:08:44 +01:00
tileset_editor_button->hide();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Reference in a new issue Copy permalink