mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-09 10:09:20 +08:00
Code Issues Packages Projects Releases Wiki Activity
d49ff7aff7
godot/scene/resources/tile_set.cpp

1249 lines
46 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* tile_set.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 20:16:55 +08:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 18:16:22 +08:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 07:50:27 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
#include "tile_set.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-12 00:13:45 +08:00
#include "core/array.h"
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
#include "core/engine.h"
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
bool TileSet::_set(const StringName &p_name, const Variant &p_value) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
String n = p_name;
int slash = n.find("/");
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 23:44:50 +08:00
if (slash == -1)
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return false;
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 23:44:50 +08:00
int id = String::to_int(n.c_str(), slash);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
if (!tile_map.has(id))
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 23:44:50 +08:00
String what = n.substr(slash + 1, n.length());
if (what == "name")
tile_set_name(id, p_value);
else if (what == "texture")
tile_set_texture(id, p_value);
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 23:15:50 +08:00
else if (what == "normal_map")
tile_set_normal_map(id, p_value);
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 23:44:50 +08:00
else if (what == "tex_offset")
tile_set_texture_offset(id, p_value);
else if (what == "material")
tile_set_material(id, p_value);
else if (what == "modulate")
tile_set_modulate(id, p_value);
else if (what == "region")
tile_set_region(id, p_value);
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
else if (what == "tile_mode")
tile_set_tile_mode(id, (TileMode)((int)p_value));
Backward compatibility for autotile setup from Godot 3.0.X Fixes #20746
2018-08-25 09:56:03 +08:00
else if (what == "is_autotile") {
// backward compatibility for Godot 3.0.x
// autotile used to be a bool, it's now an enum
bool is_autotile = p_value;
if (is_autotile)
tile_set_tile_mode(id, AUTO_TILE);
} else if (what.left(9) == "autotile/") {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
what = what.right(9);
if (what == "bitmask_mode")
autotile_set_bitmask_mode(id, (BitmaskMode)((int)p_value));
else if (what == "icon_coordinate")
autotile_set_icon_coordinate(id, p_value);
else if (what == "tile_size")
autotile_set_size(id, p_value);
else if (what == "spacing")
autotile_set_spacing(id, p_value);
else if (what == "bitmask_flags") {
tile_map[id].autotile_data.flags.clear();
if (p_value.is_array()) {
Array p = p_value;
Vector2 last_coord;
while (p.size() > 0) {
if (p[0].get_type() == Variant::VECTOR2) {
last_coord = p[0];
} else if (p[0].get_type() == Variant::INT) {
autotile_set_bitmask(id, last_coord, p[0]);
}
p.pop_front();
}
}
} else if (what == "occluder_map") {
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
tile_map[id].autotile_data.occluder_map.clear();
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Array p = p_value;
Vector2 last_coord;
while (p.size() > 0) {
if (p[0].get_type() == Variant::VECTOR2) {
last_coord = p[0];
} else if (p[0].get_type() == Variant::OBJECT) {
autotile_set_light_occluder(id, p[0], last_coord);
}
p.pop_front();
}
} else if (what == "navpoly_map") {
tile_map[id].autotile_data.navpoly_map.clear();
Array p = p_value;
Vector2 last_coord;
while (p.size() > 0) {
if (p[0].get_type() == Variant::VECTOR2) {
last_coord = p[0];
} else if (p[0].get_type() == Variant::OBJECT) {
autotile_set_navigation_polygon(id, p[0], last_coord);
}
p.pop_front();
}
} else if (what == "priority_map") {
tile_map[id].autotile_data.priority_map.clear();
Array p = p_value;
Vector3 val;
Vector2 v;
int priority;
while (p.size() > 0) {
val = p[0];
if (val.z > 1) {
v.x = val.x;
v.y = val.y;
priority = (int)val.z;
tile_map[id].autotile_data.priority_map[v] = priority;
}
p.pop_front();
}
Add Z-Index for Autotile
2018-07-02 21:39:39 +08:00
} else if (what == "z_index_map") {
tile_map[id].autotile_data.z_index_map.clear();
Array p = p_value;
Vector3 val;
Vector2 v;
int z_index;
while (p.size() > 0) {
val = p[0];
Fix AutoTile z-index not persisting correctly
2018-12-08 08:00:54 +08:00
if (val.z != 0) {
Add Z-Index for Autotile
2018-07-02 21:39:39 +08:00
v.x = val.x;
v.y = val.y;
z_index = (int)val.z;
tile_map[id].autotile_data.z_index_map[v] = z_index;
}
p.pop_front();
}
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
} else if (what == "shape")
Fix incorrect offset for old-format tilemaps
2019-11-09 00:57:51 +08:00
if (tile_get_shape_count(id) > 0) {
for (int i = 0; i < tile_get_shape_count(id); i++) {
tile_set_shape(id, i, p_value);
}
} else {
tile_set_shape(id, 0, p_value);
}
Fixing tilemap rotation for non top-left tiles.
2017-11-13 15:42:49 +08:00
else if (what == "shape_offset")
Fix incorrect offset for old-format tilemaps
2019-11-09 00:57:51 +08:00
if (tile_get_shape_count(id) > 0) {
for (int i = 0; i < tile_get_shape_count(id); i++) {
tile_set_shape_offset(id, i, p_value);
}
} else {
tile_set_shape_offset(id, 0, p_value);
}
Fixing tilemap rotation for non top-left tiles.
2017-11-13 15:42:49 +08:00
else if (what == "shape_transform")
Fix incorrect offset for old-format tilemaps
2019-11-09 00:57:51 +08:00
if (tile_get_shape_count(id) > 0) {
for (int i = 0; i < tile_get_shape_count(id); i++) {
tile_set_shape_transform(id, i, p_value);
}
} else {
tile_set_shape_transform(id, 0, p_value);
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
else if (what == "shape_one_way")
Fix incorrect offset for old-format tilemaps
2019-11-09 00:57:51 +08:00
if (tile_get_shape_count(id) > 0) {
for (int i = 0; i < tile_get_shape_count(id); i++) {
tile_set_shape_one_way(id, i, p_value);
}
} else {
tile_set_shape_one_way(id, 0, p_value);
}
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
else if (what == "shape_one_way_margin")
Fix incorrect offset for old-format tilemaps
2019-11-09 00:57:51 +08:00
if (tile_get_shape_count(id) > 0) {
for (int i = 0; i < tile_get_shape_count(id); i++) {
tile_set_shape_one_way_margin(id, i, p_value);
}
} else {
tile_set_shape_one_way_margin(id, 0, p_value);
}
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 23:44:50 +08:00
else if (what == "shapes")
_tile_set_shapes(id, p_value);
else if (what == "occluder")
tile_set_light_occluder(id, p_value);
else if (what == "occluder_offset")
tile_set_occluder_offset(id, p_value);
else if (what == "navigation")
tile_set_navigation_polygon(id, p_value);
else if (what == "navigation_offset")
tile_set_navigation_polygon_offset(id, p_value);
Adds z-index properties to TileSets.
2018-02-17 18:58:07 +08:00
else if (what == "z_index")
tile_set_z_index(id, p_value);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
else
return false;
return true;
}
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 23:44:50 +08:00
bool TileSet::_get(const StringName &p_name, Variant &r_ret) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
String n = p_name;
int slash = n.find("/");
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 23:44:50 +08:00
if (slash == -1)
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return false;
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 23:44:50 +08:00
int id = String::to_int(n.c_str(), slash);
ERR_FAIL_COND_V(!tile_map.has(id), false);
String what = n.substr(slash + 1, n.length());
if (what == "name")
r_ret = tile_get_name(id);
else if (what == "texture")
r_ret = tile_get_texture(id);
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 23:15:50 +08:00
else if (what == "normal_map")
r_ret = tile_get_normal_map(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 23:44:50 +08:00
else if (what == "tex_offset")
r_ret = tile_get_texture_offset(id);
else if (what == "material")
r_ret = tile_get_material(id);
else if (what == "modulate")
r_ret = tile_get_modulate(id);
else if (what == "region")
r_ret = tile_get_region(id);
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
else if (what == "tile_mode")
r_ret = tile_get_tile_mode(id);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
else if (what.left(9) == "autotile/") {
what = what.right(9);
if (what == "bitmask_mode")
r_ret = autotile_get_bitmask_mode(id);
else if (what == "icon_coordinate")
r_ret = autotile_get_icon_coordinate(id);
else if (what == "tile_size")
r_ret = autotile_get_size(id);
else if (what == "spacing")
r_ret = autotile_get_spacing(id);
else if (what == "bitmask_flags") {
Array p;
+ 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-04-01 01:28:42 +08:00
for (Map<Vector2, uint32_t>::Element *E = tile_map[id].autotile_data.flags.front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
p.push_back(E->key());
p.push_back(E->value());
}
r_ret = p;
} else if (what == "occluder_map") {
Array p;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
for (Map<Vector2, Ref<OccluderPolygon2D>>::Element *E = tile_map[id].autotile_data.occluder_map.front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
p.push_back(E->key());
p.push_back(E->value());
}
r_ret = p;
} else if (what == "navpoly_map") {
Array p;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
for (Map<Vector2, Ref<NavigationPolygon>>::Element *E = tile_map[id].autotile_data.navpoly_map.front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
p.push_back(E->key());
p.push_back(E->value());
}
r_ret = p;
} else if (what == "priority_map") {
Array p;
Vector3 v;
for (Map<Vector2, int>::Element *E = tile_map[id].autotile_data.priority_map.front(); E; E = E->next()) {
if (E->value() > 1) {
Fix typos in code and docs with codespell Using v1.11.0 from https://github.com/lucasdemarchi/codespell
2018-01-19 04:37:17 +08:00
//Don't save default value
Implement auto-tiling
2017-10-22 09:42:23 +08:00
v.x = E->key().x;
v.y = E->key().y;
v.z = E->value();
p.push_back(v);
}
}
r_ret = p;
Add Z-Index for Autotile
2018-07-02 21:39:39 +08:00
} else if (what == "z_index_map") {
Array p;
Vector3 v;
for (Map<Vector2, int>::Element *E = tile_map[id].autotile_data.z_index_map.front(); E; E = E->next()) {
if (E->value() != 0) {
//Don't save default value
v.x = E->key().x;
v.y = E->key().y;
v.z = E->value();
p.push_back(v);
}
}
r_ret = p;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
} else if (what == "shape")
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
r_ret = tile_get_shape(id, 0);
Readd shape_offset as an editor-only and backcompat property
2017-07-02 01:43:27 +08:00
else if (what == "shape_offset")
Fixing tilemap rotation for non top-left tiles.
2017-11-13 15:42:49 +08:00
r_ret = tile_get_shape_offset(id, 0);
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
else if (what == "shape_transform")
r_ret = tile_get_shape_transform(id, 0);
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
else if (what == "shape_one_way")
r_ret = tile_get_shape_one_way(id, 0);
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
else if (what == "shape_one_way_margin")
r_ret = tile_get_shape_one_way_margin(id, 0);
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 23:44:50 +08:00
else if (what == "shapes")
r_ret = _tile_get_shapes(id);
else if (what == "occluder")
r_ret = tile_get_light_occluder(id);
else if (what == "occluder_offset")
r_ret = tile_get_occluder_offset(id);
else if (what == "navigation")
r_ret = tile_get_navigation_polygon(id);
else if (what == "navigation_offset")
r_ret = tile_get_navigation_polygon_offset(id);
Adds z-index properties to TileSets.
2018-02-17 18:58:07 +08:00
else if (what == "z_index")
r_ret = tile_get_z_index(id);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
else
return false;
return true;
}
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 23:44:50 +08:00
void TileSet::_get_property_list(List<PropertyInfo> *p_list) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
int id = E->key();
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 23:44:50 +08:00
String pre = itos(id) + "/";
Hide TileSet's properties from the inspector
2020-02-05 03:09:59 +08:00
p_list->push_back(PropertyInfo(Variant::STRING, pre + "name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "normal_map", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D", PROPERTY_USAGE_NOEDITOR));
Hide TileSet's properties from the inspector
2020-02-05 03:09:59 +08:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "tex_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::COLOR, pre + "modulate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::RECT2, pre + "region", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::INT, pre + "tile_mode", PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE", PROPERTY_USAGE_NOEDITOR));
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
if (tile_get_tile_mode(id) == AUTO_TILE) {
Restore support for minimal 3x3 autotile sets
2018-05-17 11:39:43 +08:00
p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/bitmask_mode", PROPERTY_HINT_ENUM, "2X2,3X3 (minimal),3X3", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/bitmask_flags", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Bind many more properties to scripts Notable potentially breaking changes: - PROPERTY_USAGE_NOEDITOR is now PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_NETWORK, without PROPERTY_USAGE_INTERNAL - Some properties were renamed, and sometimes even shadowed by new ones - New getter methods (some virtual) were added
2018-01-12 06:35:12 +08:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/icon_coordinate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/spacing", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/occluder_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/navpoly_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/priority_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Add Z-Index for Autotile
2018-07-02 21:39:39 +08:00
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/z_index_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
New TileSet Editor
2018-07-30 05:54:12 +08:00
} else if (tile_get_tile_mode(id) == ATLAS_TILE) {
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/icon_coordinate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/spacing", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/occluder_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/navpoly_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Add EDITMODE_PRIORITY for ATLAS_TILE When editing ATLAS_TILE, now it's possible to enable priority to randomize subtiles.
2018-12-23 21:06:53 +08:00
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/priority_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Add z-index to ATLAS_TILE
2018-12-17 20:03:50 +08:00
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/z_index_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
Hide TileSet's properties from the inspector
2020-02-05 03:09:59 +08:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "occluder_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "occluder", PROPERTY_HINT_RESOURCE_TYPE, "OccluderPolygon2D", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "navigation_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "navigation", PROPERTY_HINT_RESOURCE_TYPE, "NavigationPolygon", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "shape_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "shape_transform", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape2D", PROPERTY_USAGE_NOEDITOR));
p_list->push_back(PropertyInfo(Variant::BOOL, pre + "shape_one_way", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-25 02:20:53 +08:00
p_list->push_back(PropertyInfo(Variant::FLOAT, pre + "shape_one_way_margin", PROPERTY_HINT_RANGE, "0,128,0.01", PROPERTY_USAGE_NOEDITOR));
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 23:44:50 +08:00
p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "shapes", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-28 02:21:27 +08:00
p_list->push_back(PropertyInfo(Variant::INT, pre + "z_index", PROPERTY_HINT_RANGE, itos(RS::CANVAS_ITEM_Z_MIN) + "," + itos(RS::CANVAS_ITEM_Z_MAX) + ",1", PROPERTY_USAGE_NOEDITOR));
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
}
void TileSet::create_tile(int p_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 23:44:50 +08:00
ERR_FAIL_COND(tile_map.has(p_id));
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id] = TileData();
Implement auto-tiling
2017-10-22 09:42:23 +08:00
tile_map[p_id].autotile_data = AutotileData();
_change_notify("");
emit_changed();
}
void TileSet::autotile_set_bitmask_mode(int p_id, BitmaskMode p_mode) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].autotile_data.bitmask_mode = p_mode;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
_change_notify("");
emit_changed();
}
Implement auto-tiling
2017-10-22 09:42:23 +08:00
TileSet::BitmaskMode TileSet::autotile_get_bitmask_mode(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), BITMASK_2X2);
return tile_map[p_id].autotile_data.bitmask_mode;
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
void TileSet::tile_set_texture(int p_id, const Ref<Texture2D> &p_texture) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].texture = p_texture;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
fix updating tileset list when assign texture and set autotile true
2018-01-11 06:45:14 +08:00
_change_notify("texture");
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
Ref<Texture2D> TileSet::tile_get_texture(int p_id) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<Texture2D>());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return tile_map[p_id].texture;
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
void TileSet::tile_set_normal_map(int p_id, const Ref<Texture2D> &p_normal_map) {
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 23:15:50 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].normal_map = p_normal_map;
emit_changed();
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
Ref<Texture2D> TileSet::tile_get_normal_map(int p_id) const {
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 23:15:50 +08:00
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-12 02:43:37 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<Texture2D>());
Add normal map to tilemaps and tilesets Fixes #9310
2017-06-22 23:15:50 +08:00
return tile_map[p_id].normal_map;
}
New particle system, mostly working, some small features missing.
2017-04-07 10:36:37 +08:00
void TileSet::tile_set_material(int p_id, const Ref<ShaderMaterial> &p_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 13:34:56 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].material = p_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 13:34:56 +08:00
emit_changed();
}
New particle system, mostly working, some small features missing.
2017-04-07 10:36:37 +08:00
Ref<ShaderMaterial> TileSet::tile_get_material(int p_id) const {
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 13:34:56 +08:00
New particle system, mostly working, some small features missing.
2017-04-07 10:36:37 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<ShaderMaterial>());
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 13:34:56 +08:00
return tile_map[p_id].material;
}
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 23:44:50 +08:00
void TileSet::tile_set_modulate(int p_id, const Color &p_modulate) {
Add modulate (color) to TileSet tiles
2016-11-30 21:33:39 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].modulate = p_modulate;
Add modulate (color) to TileSet tiles
2016-11-30 21:33:39 +08:00
emit_changed();
Fix converting to tileset crashes Godot if existing file is not tileset also make TileSetEditorPlgn tile list updates the preview modulate
2018-03-11 22:59:50 +08:00
_change_notify("modulate");
Add modulate (color) to TileSet tiles
2016-11-30 21:33:39 +08: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 23:44:50 +08:00
Color TileSet::tile_get_modulate(int p_id) const {
Add modulate (color) to TileSet tiles
2016-11-30 21:33:39 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Color(1, 1, 1));
Add modulate (color) to TileSet tiles
2016-11-30 21:33:39 +08:00
return tile_map[p_id].modulate;
}
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 23:44:50 +08:00
void TileSet::tile_set_texture_offset(int p_id, const Vector2 &p_offset) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].offset = p_offset;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
}
-improved physics ccd -html5 exporter works again -disable repeat on image loader by default -can change shape offset en tileset, texture offset was broken
2014-02-19 22:57:14 +08:00
Vector2 TileSet::tile_get_texture_offset(int p_id) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return tile_map[p_id].offset;
}
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 23:44:50 +08:00
void TileSet::tile_set_region(int p_id, const Rect2 &p_region) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].region = p_region;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
_change_notify("region");
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Rect2 TileSet::tile_get_region(int p_id) const {
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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Rect2());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return tile_map[p_id].region;
}
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
void TileSet::tile_set_tile_mode(int p_id, TileMode p_tile_mode) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
tile_map[p_id].tile_mode = p_tile_mode;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
emit_changed();
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
_change_notify("tile_mode");
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
TileSet::TileMode TileSet::tile_get_tile_mode(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), SINGLE_TILE);
return tile_map[p_id].tile_mode;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
void TileSet::autotile_set_icon_coordinate(int p_id, Vector2 coord) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].autotile_data.icon_coord = coord;
emit_changed();
}
Vector2 TileSet::autotile_get_icon_coordinate(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
return tile_map[p_id].autotile_data.icon_coord;
}
void TileSet::autotile_set_spacing(int p_id, int p_spacing) {
ERR_FAIL_COND(!tile_map.has(p_id));
ERR_FAIL_COND(p_spacing < 0);
tile_map[p_id].autotile_data.spacing = p_spacing;
emit_changed();
}
int TileSet::autotile_get_spacing(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
return tile_map[p_id].autotile_data.spacing;
}
void TileSet::autotile_set_size(int p_id, Size2 p_size) {
ERR_FAIL_COND(!tile_map.has(p_id));
ERR_FAIL_COND(p_size.x <= 0 || p_size.y <= 0);
tile_map[p_id].autotile_data.size = p_size;
}
Size2 TileSet::autotile_get_size(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), Size2());
return tile_map[p_id].autotile_data.size;
}
void TileSet::autotile_clear_bitmask_map(int p_id) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].autotile_data.flags.clear();
}
void TileSet::autotile_set_subtile_priority(int p_id, const Vector2 &p_coord, int p_priority) {
ERR_FAIL_COND(!tile_map.has(p_id));
ERR_FAIL_COND(p_priority <= 0);
tile_map[p_id].autotile_data.priority_map[p_coord] = p_priority;
}
int TileSet::autotile_get_subtile_priority(int p_id, const Vector2 &p_coord) {
ERR_FAIL_COND_V(!tile_map.has(p_id), 1);
if (tile_map[p_id].autotile_data.priority_map.has(p_coord)) {
return tile_map[p_id].autotile_data.priority_map[p_coord];
}
//When not custom priority set return the default value
return 1;
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-20 00:20:49 +08:00
const Map<Vector2, int> &TileSet::autotile_get_priority_map(int p_id) const {
static Map<Vector2, int> dummy;
ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
return tile_map[p_id].autotile_data.priority_map;
}
Add Z-Index for Autotile
2018-07-02 21:39:39 +08:00
void TileSet::autotile_set_z_index(int p_id, const Vector2 &p_coord, int p_z_index) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].autotile_data.z_index_map[p_coord] = p_z_index;
emit_changed();
}
int TileSet::autotile_get_z_index(int p_id, const Vector2 &p_coord) {
ERR_FAIL_COND_V(!tile_map.has(p_id), 1);
if (tile_map[p_id].autotile_data.z_index_map.has(p_coord)) {
return tile_map[p_id].autotile_data.z_index_map[p_coord];
}
//When not custom z index set return the default value
return 0;
}
Add undo-redo to the TileSet editor, and other improvements
2018-12-20 00:20:49 +08:00
const Map<Vector2, int> &TileSet::autotile_get_z_index_map(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
static Map<Vector2, int> dummy;
ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
Add undo-redo to the TileSet editor, and other improvements
2018-12-20 00:20:49 +08:00
return tile_map[p_id].autotile_data.z_index_map;
Implement auto-tiling
2017-10-22 09:42:23 +08: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-04-01 01:28:42 +08:00
void TileSet::autotile_set_bitmask(int p_id, Vector2 p_coord, uint32_t p_flag) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
if (p_flag == 0) {
if (tile_map[p_id].autotile_data.flags.has(p_coord))
tile_map[p_id].autotile_data.flags.erase(p_coord);
} else {
tile_map[p_id].autotile_data.flags[p_coord] = p_flag;
}
}
+ 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-04-01 01:28:42 +08:00
uint32_t TileSet::autotile_get_bitmask(int p_id, Vector2 p_coord) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
if (!tile_map[p_id].autotile_data.flags.has(p_coord)) {
return 0;
}
return tile_map[p_id].autotile_data.flags[p_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-04-01 01:28:42 +08:00
const Map<Vector2, uint32_t> &TileSet::autotile_get_bitmask_map(int p_id) {
Implement auto-tiling
2017-10-22 09:42:23 +08: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-04-01 01:28:42 +08:00
static Map<Vector2, uint32_t> dummy;
static Map<Vector2, uint32_t> dummy_atlas;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
New TileSet Editor
2018-07-30 05:54:12 +08:00
if (tile_get_tile_mode(p_id) == ATLAS_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-04-01 01:28:42 +08:00
dummy_atlas = Map<Vector2, uint32_t>();
New TileSet Editor
2018-07-30 05:54:12 +08:00
Rect2 region = tile_get_region(p_id);
Size2 size = autotile_get_size(p_id);
float spacing = autotile_get_spacing(p_id);
for (int x = 0; x < (region.size.x / (size.x + spacing)); x++) {
for (int y = 0; y < (region.size.y / (size.y + spacing)); y++) {
dummy_atlas.insert(Vector2(x, y), 0);
}
}
return dummy_atlas;
} else
return tile_map[p_id].autotile_data.flags;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
Vector2 TileSet::autotile_get_subtile_for_bitmask(int p_id, uint16_t p_bitmask, const Node *p_tilemap_node, const Vector2 &p_tile_location) {
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
//First try to forward selection to script
if (p_tilemap_node->get_class_name() == "TileMap") {
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
if (get_script_instance() != nullptr) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
if (get_script_instance()->has_method("_forward_subtile_selection")) {
Variant ret = get_script_instance()->call("_forward_subtile_selection", p_id, p_bitmask, p_tilemap_node, p_tile_location);
if (ret.get_type() == Variant::VECTOR2) {
return ret;
}
}
}
}
List<Vector2> coords;
Changed autotile priority picking algorithm
2019-04-07 19:09:38 +08:00
List<uint32_t> priorities;
uint32_t priority_sum = 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-04-01 01:28:42 +08:00
uint32_t mask;
uint16_t mask_;
uint16_t mask_ignore;
for (Map<Vector2, uint32_t>::Element *E = tile_map[p_id].autotile_data.flags.front(); E; E = E->next()) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
mask = E->get();
if (tile_map[p_id].autotile_data.bitmask_mode == 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-04-01 01:28:42 +08:00
mask |= (BIND_IGNORE_TOP | BIND_IGNORE_LEFT | BIND_IGNORE_CENTER | BIND_IGNORE_RIGHT | BIND_IGNORE_BOTTOM);
Implement auto-tiling
2017-10-22 09:42:23 +08: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-04-01 01:28:42 +08:00
mask_ = mask & 0xFFFF;
mask_ignore = mask >> 16;
if (((mask_ & (~mask_ignore)) == (p_bitmask & (~mask_ignore))) && (((~mask_) | mask_ignore) == ((~p_bitmask) | mask_ignore))) {
Changed autotile priority picking algorithm
2019-04-07 19:09:38 +08:00
uint32_t priority = autotile_get_subtile_priority(p_id, E->key());
priority_sum += priority;
priorities.push_back(priority);
coords.push_back(E->key());
Implement auto-tiling
2017-10-22 09:42:23 +08: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-04-01 01:28:42 +08:00
Implement auto-tiling
2017-10-22 09:42:23 +08:00
if (coords.size() == 0) {
return autotile_get_icon_coordinate(p_id);
} else {
Changed autotile priority picking algorithm
2019-04-07 19:09:38 +08:00
uint32_t picked_value = Math::rand() % priority_sum;
uint32_t upper_bound;
uint32_t lower_bound = 0;
Vector2 result = coords.front()->get();
List<Vector2>::Element *coords_E = coords.front();
List<uint32_t>::Element *priorities_E = priorities.front();
while (priorities_E) {
upper_bound = lower_bound + priorities_E->get();
if (lower_bound <= picked_value && picked_value < upper_bound) {
result = coords_E->get();
break;
}
lower_bound = upper_bound;
priorities_E = priorities_E->next();
coords_E = coords_E->next();
}
return result;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
}
Add EDITMODE_PRIORITY for ATLAS_TILE When editing ATLAS_TILE, now it's possible to enable priority to randomize subtiles.
2018-12-23 21:06:53 +08:00
Vector2 TileSet::atlastile_get_subtile_by_priority(int p_id, const Node *p_tilemap_node, const Vector2 &p_tile_location) {
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
//First try to forward selection to script
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
if (get_script_instance() != nullptr) {
Add EDITMODE_PRIORITY for ATLAS_TILE When editing ATLAS_TILE, now it's possible to enable priority to randomize subtiles.
2018-12-23 21:06:53 +08:00
if (get_script_instance()->has_method("_forward_atlas_subtile_selection")) {
Variant ret = get_script_instance()->call("_forward_atlas_subtile_selection", p_id, p_tilemap_node, p_tile_location);
if (ret.get_type() == Variant::VECTOR2) {
return ret;
}
}
}
Vector2 coord = tile_get_region(p_id).size / autotile_get_size(p_id);
List<Vector2> coords;
for (int x = 0; x < coord.x; x++) {
for (int y = 0; y < coord.y; y++) {
for (int i = 0; i < autotile_get_subtile_priority(p_id, Vector2(x, y)); i++) {
coords.push_back(Vector2(x, y));
}
}
}
if (coords.size() == 0) {
return autotile_get_icon_coordinate(p_id);
} else {
return coords[Math::random(0, (int)coords.size())];
}
}
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 23:44:50 +08:00
void TileSet::tile_set_name(int p_id, const String &p_name) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].name = p_name;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
Tileset Editor Improvement
2018-02-17 19:08:44 +08:00
_change_notify("name");
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
String TileSet::tile_get_name(int p_id) const {
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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), String());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return tile_map[p_id].name;
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
void TileSet::tile_clear_shapes(int p_id) {
Fix some editor crashes
2019-06-21 17:34:32 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data.clear();
}
Implement auto-tiling
2017-10-22 09:42:23 +08:00
void TileSet::tile_add_shape(int p_id, const Ref<Shape2D> &p_shape, const Transform2D &p_transform, bool p_one_way, const Vector2 &p_autotile_coord) {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
ShapeData new_data = ShapeData();
new_data.shape = p_shape;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
new_data.shape_transform = p_transform;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
new_data.one_way_collision = p_one_way;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
new_data.autotile_coord = p_autotile_coord;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data.push_back(new_data);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
int TileSet::tile_get_shape_count(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
return tile_map[p_id].shapes_data.size();
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
void TileSet::tile_set_shape(int p_id, int p_shape_id, const Ref<Shape2D> &p_shape) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Fix some editor crashes
2019-06-21 17:34:32 +08:00
ERR_FAIL_COND(p_shape_id < 0);
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id >= tile_map[p_id].shapes_data.size())
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data.resize(p_shape_id + 1);
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 09:11:03 +08:00
tile_map[p_id].shapes_data.write[p_shape_id].shape = p_shape;
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
_decompose_convex_shape(p_shape);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
Ref<Shape2D> TileSet::tile_get_shape(int p_id, int p_shape_id) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<Shape2D>());
Fix crash with TileSet(again)
2019-07-03 23:18:36 +08:00
ERR_FAIL_COND_V(p_shape_id < 0, Ref<Shape2D>());
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id < tile_map[p_id].shapes_data.size())
return tile_map[p_id].shapes_data[p_shape_id].shape;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
return Ref<Shape2D>();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
void TileSet::tile_set_shape_transform(int p_id, int p_shape_id, const Transform2D &p_offset) {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Fix crash with TileSet(again)
2019-07-03 23:18:36 +08:00
ERR_FAIL_COND(p_shape_id < 0);
Fix some editor crashes
2019-06-21 17:34:32 +08:00
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id >= tile_map[p_id].shapes_data.size())
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data.resize(p_shape_id + 1);
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 09:11:03 +08:00
tile_map[p_id].shapes_data.write[p_shape_id].shape_transform = p_offset;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
emit_changed();
}
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
Transform2D TileSet::tile_get_shape_transform(int p_id, int p_shape_id) const {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Transform2D());
Fix crash with TileSet(again)
2019-07-03 23:18:36 +08:00
ERR_FAIL_COND_V(p_shape_id < 0, Transform2D());
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id < tile_map[p_id].shapes_data.size())
return tile_map[p_id].shapes_data[p_shape_id].shape_transform;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
return Transform2D();
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
}
Fixing tilemap rotation for non top-left tiles.
2017-11-13 15:42:49 +08:00
void TileSet::tile_set_shape_offset(int p_id, int p_shape_id, const Vector2 &p_offset) {
Transform2D transform = tile_get_shape_transform(p_id, p_shape_id);
transform.set_origin(p_offset);
tile_set_shape_transform(p_id, p_shape_id, transform);
}
Vector2 TileSet::tile_get_shape_offset(int p_id, int p_shape_id) const {
return tile_get_shape_transform(p_id, p_shape_id).get_origin();
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
void TileSet::tile_set_shape_one_way(int p_id, int p_shape_id, const bool p_one_way) {
ERR_FAIL_COND(!tile_map.has(p_id));
Fix some editor crashes
2019-06-21 17:34:32 +08:00
ERR_FAIL_COND(p_shape_id < 0);
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id >= tile_map[p_id].shapes_data.size())
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data.resize(p_shape_id + 1);
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 09:11:03 +08:00
tile_map[p_id].shapes_data.write[p_shape_id].one_way_collision = p_one_way;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
emit_changed();
}
bool TileSet::tile_get_shape_one_way(int p_id, int p_shape_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), false);
Fix crash with TileSet(again)
2019-07-03 23:18:36 +08:00
ERR_FAIL_COND_V(p_shape_id < 0, false);
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id < tile_map[p_id].shapes_data.size())
return tile_map[p_id].shapes_data[p_shape_id].one_way_collision;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
return false;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
}
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
void TileSet::tile_set_shape_one_way_margin(int p_id, int p_shape_id, float p_margin) {
Fix some editor crashes
2019-06-21 17:34:32 +08:00
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Fix some editor crashes
2019-06-21 17:34:32 +08:00
ERR_FAIL_COND(p_shape_id < 0);
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id >= tile_map[p_id].shapes_data.size())
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
tile_map[p_id].shapes_data.resize(p_shape_id + 1);
tile_map[p_id].shapes_data.write[p_shape_id].one_way_collision_margin = p_margin;
emit_changed();
}
float TileSet::tile_get_shape_one_way_margin(int p_id, int p_shape_id) const {
Fix some editor crashes
2019-06-21 17:34:32 +08:00
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
Fix crash with TileSet(again)
2019-07-03 23:18:36 +08:00
ERR_FAIL_COND_V(p_shape_id < 0, 0);
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
if (p_shape_id < tile_map[p_id].shapes_data.size())
return tile_map[p_id].shapes_data[p_shape_id].one_way_collision_margin;
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
TileSet: Don't error out on tile_ getters with wrong shape id Partial revert of 02319dceb2e17184eb765c67719a306f56dafc1b, previous code handled this cases without errors and the TileSet and TileSetEditorPlugin are written with the expectation that those will not error out. This is a bit wonky and these classes should likely be refactored, but until then it's best to keep things as they were. Fixes #29962.
2019-06-23 19:56:44 +08:00
return 0;
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08: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 23:44:50 +08:00
void TileSet::tile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder) {
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 13:34:56 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].occluder = p_light_occluder;
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 13:34:56 +08: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 23:44:50 +08:00
Ref<OccluderPolygon2D> TileSet::tile_get_light_occluder(int p_id) const {
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 13:34:56 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<OccluderPolygon2D>());
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 13:34:56 +08:00
return tile_map[p_id].occluder;
}
Implement auto-tiling
2017-10-22 09:42:23 +08:00
void TileSet::autotile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder, const Vector2 &p_coord) {
ERR_FAIL_COND(!tile_map.has(p_id));
if (p_light_occluder.is_null()) {
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
if (tile_map[p_id].autotile_data.occluder_map.has(p_coord)) {
tile_map[p_id].autotile_data.occluder_map.erase(p_coord);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
} else {
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
tile_map[p_id].autotile_data.occluder_map[p_coord] = p_light_occluder;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
}
Ref<OccluderPolygon2D> TileSet::autotile_get_light_occluder(int p_id, const Vector2 &p_coord) const {
Fix some editor crashes
2019-06-21 17:34:32 +08:00
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<OccluderPolygon2D>());
Fix some editor crashes
2019-06-21 17:34:32 +08:00
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
if (!tile_map[p_id].autotile_data.occluder_map.has(p_coord)) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
return Ref<OccluderPolygon2D>();
} else {
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
return tile_map[p_id].autotile_data.occluder_map[p_coord];
Implement auto-tiling
2017-10-22 09:42:23 +08: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 23:44:50 +08:00
void TileSet::tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offset) {
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 13:34:56 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].navigation_polygon_offset = p_offset;
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 13:34:56 +08: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 23:44:50 +08:00
Vector2 TileSet::tile_get_navigation_polygon_offset(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
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 13:34:56 +08:00
return tile_map[p_id].navigation_polygon_offset;
}
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 23:44:50 +08:00
void TileSet::tile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_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 13:34:56 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].navigation_polygon = p_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 13:34:56 +08:00
}
Ref<NavigationPolygon> TileSet::tile_get_navigation_polygon(int p_id) const {
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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<NavigationPolygon>());
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 13:34:56 +08:00
return tile_map[p_id].navigation_polygon;
}
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
const Map<Vector2, Ref<OccluderPolygon2D>> &TileSet::autotile_get_light_oclusion_map(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
static Map<Vector2, Ref<OccluderPolygon2D>> dummy;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
Fix TileSet::AutotileData::ocludder_map typo
2017-12-09 03:38:36 +08:00
return tile_map[p_id].autotile_data.occluder_map;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
}
void TileSet::autotile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_navigation_polygon, const Vector2 &p_coord) {
ERR_FAIL_COND(!tile_map.has(p_id));
if (p_navigation_polygon.is_null()) {
if (tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) {
tile_map[p_id].autotile_data.navpoly_map.erase(p_coord);
}
} else {
tile_map[p_id].autotile_data.navpoly_map[p_coord] = p_navigation_polygon;
}
}
Ref<NavigationPolygon> TileSet::autotile_get_navigation_polygon(int p_id, const Vector2 &p_coord) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<NavigationPolygon>());
if (!tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) {
return Ref<NavigationPolygon>();
} else {
return tile_map[p_id].autotile_data.navpoly_map[p_coord];
}
}
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
const Map<Vector2, Ref<NavigationPolygon>> &TileSet::autotile_get_navigation_map(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
static Map<Vector2, Ref<NavigationPolygon>> dummy;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
return tile_map[p_id].autotile_data.navpoly_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 23:44:50 +08:00
void TileSet::tile_set_occluder_offset(int p_id, const Vector2 &p_offset) {
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 13:34:56 +08:00
ERR_FAIL_COND(!tile_map.has(p_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 23:44:50 +08:00
tile_map[p_id].occluder_offset = p_offset;
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 13:34:56 +08: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 23:44:50 +08:00
Vector2 TileSet::tile_get_occluder_offset(int p_id) const {
Implement auto-tiling
2017-10-22 09:42:23 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
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 13:34:56 +08:00
return tile_map[p_id].occluder_offset;
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
void TileSet::tile_set_shapes(int p_id, const Vector<ShapeData> &p_shapes) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data = p_shapes;
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
for (int i = 0; i < p_shapes.size(); i++) {
_decompose_convex_shape(p_shapes[i].shape);
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
emit_changed();
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
Vector<TileSet::ShapeData> TileSet::tile_get_shapes(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), Vector<ShapeData>());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
return tile_map[p_id].shapes_data;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Adds z-index properties to TileSets.
2018-02-17 18:58:07 +08:00
int TileSet::tile_get_z_index(int p_id) const {
ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
return tile_map[p_id].z_index;
}
void TileSet::tile_set_z_index(int p_id, int p_z_index) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map[p_id].z_index = p_z_index;
emit_changed();
}
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 23:44:50 +08:00
void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!tile_map.has(p_id));
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
Vector<ShapeData> shapes_data;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
Transform2D default_transform = tile_get_shape_transform(p_id, 0);
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
bool default_one_way = tile_get_shape_one_way(p_id, 0);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Vector2 default_autotile_coord = Vector2();
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 23:44:50 +08:00
for (int i = 0; i < p_shapes.size(); i++) {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
ShapeData s = ShapeData();
if (p_shapes[i].get_type() == Variant::OBJECT) {
Ref<Shape2D> shape = p_shapes[i];
if (shape.is_null()) continue;
s.shape = shape;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
s.shape_transform = default_transform;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
s.one_way_collision = default_one_way;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
s.autotile_coord = default_autotile_coord;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
} else if (p_shapes[i].get_type() == Variant::DICTIONARY) {
Dictionary d = p_shapes[i];
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
if (d.has("shape") && d["shape"].get_type() == Variant::OBJECT) {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
s.shape = d["shape"];
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
_decompose_convex_shape(s.shape);
} else
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
continue;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
if (d.has("shape_transform") && d["shape_transform"].get_type() == Variant::TRANSFORM2D)
s.shape_transform = d["shape_transform"];
else if (d.has("shape_offset") && d["shape_offset"].get_type() == Variant::VECTOR2)
s.shape_transform = Transform2D(0, (Vector2)d["shape_offset"]);
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
else
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
s.shape_transform = default_transform;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
if (d.has("one_way") && d["one_way"].get_type() == Variant::BOOL)
s.one_way_collision = d["one_way"];
else
s.one_way_collision = default_one_way;
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
if (d.has("one_way_margin") && d["one_way_margin"].is_num())
s.one_way_collision_margin = d["one_way_margin"];
else
Fix collision margin being wrongly read by default, fixes #25181
2019-01-22 21:14:43 +08:00
s.one_way_collision_margin = 1.0;
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
Implement auto-tiling
2017-10-22 09:42:23 +08:00
if (d.has("autotile_coord") && d["autotile_coord"].get_type() == Variant::VECTOR2)
s.autotile_coord = d["autotile_coord"];
else
s.autotile_coord = default_autotile_coord;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
} else {
Remove ERR_EXPLAIN from scene/* code
2019-08-09 04:11:48 +08:00
ERR_CONTINUE_MSG(true, "Expected an array of objects or dictionaries for tile_set_shapes.");
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
}
shapes_data.push_back(s);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
tile_map[p_id].shapes_data = shapes_data;
Fix TileSet shape data not updating when being set via code
2020-01-23 22:48:38 +08:00
emit_changed();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
Array TileSet::_tile_get_shapes(int p_id) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
ERR_FAIL_COND_V(!tile_map.has(p_id), Array());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Array arr;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
Vector<ShapeData> data = tile_map[p_id].shapes_data;
for (int i = 0; i < data.size(); i++) {
Dictionary shape_data;
shape_data["shape"] = data[i].shape;
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
shape_data["shape_transform"] = data[i].shape_transform;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
shape_data["one_way"] = data[i].one_way_collision;
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
shape_data["one_way_margin"] = data[i].one_way_collision_margin;
Implement auto-tiling
2017-10-22 09:42:23 +08:00
shape_data["autotile_coord"] = data[i].autotile_coord;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
arr.push_back(shape_data);
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return arr;
}
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 23:44:50 +08:00
Array TileSet::_get_tiles_ids() const {
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Added function "get_tiles_ids" to TreeSet.
2014-02-18 17:49:34 +08:00
Array arr;
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
remove trailing whitespace
2016-03-09 07:00:52 +08:00
arr.push_back(E->key());
Added function "get_tiles_ids" to TreeSet.
2014-02-18 17:49:34 +08:00
}
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Added function "get_tiles_ids" to TreeSet.
2014-02-18 17:49:34 +08:00
return arr;
}
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
void TileSet::_decompose_convex_shape(Ref<Shape2D> p_shape) {
if (Engine::get_singleton()->is_editor_hint())
return;
Ref<ConvexPolygonShape2D> convex = p_shape;
if (!convex.is_valid())
return;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
Vector<Vector<Vector2>> decomp = Geometry::decompose_polygon_in_convex(convex->get_points());
TileSet/TileMap: Decompose solid non-convex polygons into convexes. Real fix for #24003
2019-03-04 10:05:43 +08:00
if (decomp.size() > 1) {
Array sub_shapes;
for (int i = 0; i < decomp.size(); i++) {
Ref<ConvexPolygonShape2D> _convex = memnew(ConvexPolygonShape2D);
_convex->set_points(decomp[i]);
sub_shapes.append(_convex);
}
convex->set_meta("decomposed", sub_shapes);
} else {
convex->set_meta("decomposed", Variant());
}
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void TileSet::get_tile_list(List<int> *p_tiles) const {
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
p_tiles->push_back(E->key());
}
}
bool TileSet::has_tile(int p_id) const {
return tile_map.has(p_id);
}
Implement auto-tiling
2017-10-22 09:42:23 +08:00
bool TileSet::is_tile_bound(int p_drawn_id, int p_neighbor_id) {
if (p_drawn_id == p_neighbor_id) {
return true;
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
} else if (get_script_instance() != nullptr) {
Implement auto-tiling
2017-10-22 09:42:23 +08:00
if (get_script_instance()->has_method("_is_tile_bound")) {
Variant ret = get_script_instance()->call("_is_tile_bound", p_drawn_id, p_neighbor_id);
if (ret.get_type() == Variant::BOOL) {
return ret;
}
}
}
return false;
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void TileSet::remove_tile(int p_id) {
ERR_FAIL_COND(!tile_map.has(p_id));
tile_map.erase(p_id);
_change_notify("");
emit_changed();
}
int TileSet::get_last_unused_tile_id() const {
if (tile_map.size())
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 23:44:50 +08:00
return tile_map.back()->key() + 1;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
else
return 0;
}
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 23:44:50 +08:00
int TileSet::find_tile_by_name(const String &p_name) const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
if (p_name == E->get().name)
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return E->key();
}
return -1;
}
void TileSet::clear() {
tile_map.clear();
_change_notify("");
emit_changed();
}
void TileSet::_bind_methods() {
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("create_tile", "id"), &TileSet::create_tile);
Add undo-redo to the TileSet editor, and other improvements
2018-12-20 00:20:49 +08:00
ClassDB::bind_method(D_METHOD("autotile_clear_bitmask_map", "id"), &TileSet::autotile_clear_bitmask_map);
ClassDB::bind_method(D_METHOD("autotile_set_icon_coordinate", "id", "coord"), &TileSet::autotile_set_icon_coordinate);
ClassDB::bind_method(D_METHOD("autotile_get_icon_coordinate", "id"), &TileSet::autotile_get_icon_coordinate);
ClassDB::bind_method(D_METHOD("autotile_set_subtile_priority", "id", "coord", "priority"), &TileSet::autotile_set_subtile_priority);
ClassDB::bind_method(D_METHOD("autotile_get_subtile_priority", "id", "coord"), &TileSet::autotile_get_subtile_priority);
ClassDB::bind_method(D_METHOD("autotile_set_z_index", "id", "coord", "z_index"), &TileSet::autotile_set_z_index);
ClassDB::bind_method(D_METHOD("autotile_get_z_index", "id", "coord"), &TileSet::autotile_get_z_index);
ClassDB::bind_method(D_METHOD("autotile_set_light_occluder", "id", "light_occluder", "coord"), &TileSet::autotile_set_light_occluder);
ClassDB::bind_method(D_METHOD("autotile_get_light_occluder", "id", "coord"), &TileSet::autotile_get_light_occluder);
ClassDB::bind_method(D_METHOD("autotile_set_navigation_polygon", "id", "navigation_polygon", "coord"), &TileSet::autotile_set_navigation_polygon);
ClassDB::bind_method(D_METHOD("autotile_get_navigation_polygon", "id", "coord"), &TileSet::autotile_get_navigation_polygon);
ClassDB::bind_method(D_METHOD("autotile_set_bitmask", "id", "bitmask", "flag"), &TileSet::autotile_set_bitmask);
ClassDB::bind_method(D_METHOD("autotile_get_bitmask", "id", "coord"), &TileSet::autotile_get_bitmask);
Add missing parameter names
2017-12-25 22:19:56 +08:00
ClassDB::bind_method(D_METHOD("autotile_set_bitmask_mode", "id", "mode"), &TileSet::autotile_set_bitmask_mode);
ClassDB::bind_method(D_METHOD("autotile_get_bitmask_mode", "id"), &TileSet::autotile_get_bitmask_mode);
Add undo-redo to the TileSet editor, and other improvements
2018-12-20 00:20:49 +08:00
ClassDB::bind_method(D_METHOD("autotile_set_spacing", "id", "spacing"), &TileSet::autotile_set_spacing);
ClassDB::bind_method(D_METHOD("autotile_get_spacing", "id"), &TileSet::autotile_get_spacing);
Tileset: Bind autotile_set_size()/get_size(). Since this class is editor-oriented, this set_get is necessary to full implement tool, importer, etc... for tiles. (No other way to know a real tile size in autotile mode)
2018-08-31 02:56:38 +08:00
ClassDB::bind_method(D_METHOD("autotile_set_size", "id", "size"), &TileSet::autotile_set_size);
ClassDB::bind_method(D_METHOD("autotile_get_size", "id"), &TileSet::autotile_get_size);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("tile_set_name", "id", "name"), &TileSet::tile_set_name);
ClassDB::bind_method(D_METHOD("tile_get_name", "id"), &TileSet::tile_get_name);
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("tile_set_texture", "id", "texture"), &TileSet::tile_set_texture);
ClassDB::bind_method(D_METHOD("tile_get_texture", "id"), &TileSet::tile_get_texture);
ClassDB::bind_method(D_METHOD("tile_set_normal_map", "id", "normal_map"), &TileSet::tile_set_normal_map);
ClassDB::bind_method(D_METHOD("tile_get_normal_map", "id"), &TileSet::tile_get_normal_map);
ClassDB::bind_method(D_METHOD("tile_set_material", "id", "material"), &TileSet::tile_set_material);
ClassDB::bind_method(D_METHOD("tile_get_material", "id"), &TileSet::tile_get_material);
Expose 'modulate' set/get in TileSet resource
2018-07-24 05:32:20 +08:00
ClassDB::bind_method(D_METHOD("tile_set_modulate", "id", "color"), &TileSet::tile_set_modulate);
ClassDB::bind_method(D_METHOD("tile_get_modulate", "id"), &TileSet::tile_get_modulate);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("tile_set_texture_offset", "id", "texture_offset"), &TileSet::tile_set_texture_offset);
ClassDB::bind_method(D_METHOD("tile_get_texture_offset", "id"), &TileSet::tile_get_texture_offset);
ClassDB::bind_method(D_METHOD("tile_set_region", "id", "region"), &TileSet::tile_set_region);
ClassDB::bind_method(D_METHOD("tile_get_region", "id"), &TileSet::tile_get_region);
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shape", "id", "shape_id", "shape"), &TileSet::tile_set_shape);
ClassDB::bind_method(D_METHOD("tile_get_shape", "id", "shape_id"), &TileSet::tile_get_shape);
TileSet: Bind tile_set_shape_offset and getter Fixes #21476.
2018-08-27 17:09:11 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shape_offset", "id", "shape_id", "shape_offset"), &TileSet::tile_set_shape_offset);
ClassDB::bind_method(D_METHOD("tile_get_shape_offset", "id", "shape_id"), &TileSet::tile_get_shape_offset);
Readd tilemap's shape_transform and bugfixes This reverts commit a808f53020aa710ff81392e2349b8a39c55d2717.
2017-07-02 01:56:51 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shape_transform", "id", "shape_id", "shape_transform"), &TileSet::tile_set_shape_transform);
ClassDB::bind_method(D_METHOD("tile_get_shape_transform", "id", "shape_id"), &TileSet::tile_get_shape_transform);
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shape_one_way", "id", "shape_id", "one_way"), &TileSet::tile_set_shape_one_way);
ClassDB::bind_method(D_METHOD("tile_get_shape_one_way", "id", "shape_id"), &TileSet::tile_get_shape_one_way);
-Re-added margins in one way collision (made in a more user friendly way than in Godot 2.1), fixes #23860 -Fixed potential bug in OWC (i dont think anyone had it but..)
2019-01-19 01:15:05 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shape_one_way_margin", "id", "shape_id", "one_way"), &TileSet::tile_set_shape_one_way_margin);
ClassDB::bind_method(D_METHOD("tile_get_shape_one_way_margin", "id", "shape_id"), &TileSet::tile_get_shape_one_way_margin);
Fix TileMap and TileSet ClassDB bindings
2017-11-24 12:43:15 +08:00
ClassDB::bind_method(D_METHOD("tile_add_shape", "id", "shape", "shape_transform", "one_way", "autotile_coord"), &TileSet::tile_add_shape, DEFVAL(false), DEFVAL(Vector2()));
Add one-way collisions and individual shape offsets for tilesets As requested in #9318 Accidentially fixes #2231 as well
2017-06-26 02:47:30 +08:00
ClassDB::bind_method(D_METHOD("tile_get_shape_count", "id"), &TileSet::tile_get_shape_count);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("tile_set_shapes", "id", "shapes"), &TileSet::_tile_set_shapes);
ClassDB::bind_method(D_METHOD("tile_get_shapes", "id"), &TileSet::_tile_get_shapes);
expose Tileset TileMode to GDScript
2018-04-09 04:54:02 +08:00
ClassDB::bind_method(D_METHOD("tile_set_tile_mode", "id", "tilemode"), &TileSet::tile_set_tile_mode);
ClassDB::bind_method(D_METHOD("tile_get_tile_mode", "id"), &TileSet::tile_get_tile_mode);
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("tile_set_navigation_polygon", "id", "navigation_polygon"), &TileSet::tile_set_navigation_polygon);
ClassDB::bind_method(D_METHOD("tile_get_navigation_polygon", "id"), &TileSet::tile_get_navigation_polygon);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("tile_set_navigation_polygon_offset", "id", "navigation_polygon_offset"), &TileSet::tile_set_navigation_polygon_offset);
ClassDB::bind_method(D_METHOD("tile_get_navigation_polygon_offset", "id"), &TileSet::tile_get_navigation_polygon_offset);
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("tile_set_light_occluder", "id", "light_occluder"), &TileSet::tile_set_light_occluder);
ClassDB::bind_method(D_METHOD("tile_get_light_occluder", "id"), &TileSet::tile_get_light_occluder);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("tile_set_occluder_offset", "id", "occluder_offset"), &TileSet::tile_set_occluder_offset);
ClassDB::bind_method(D_METHOD("tile_get_occluder_offset", "id"), &TileSet::tile_get_occluder_offset);
Adds z-index properties to TileSets.
2018-02-17 18:58:07 +08:00
ClassDB::bind_method(D_METHOD("tile_set_z_index", "id", "z_index"), &TileSet::tile_set_z_index);
ClassDB::bind_method(D_METHOD("tile_get_z_index", "id"), &TileSet::tile_get_z_index);
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 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("remove_tile", "id"), &TileSet::remove_tile);
ClassDB::bind_method(D_METHOD("clear"), &TileSet::clear);
ClassDB::bind_method(D_METHOD("get_last_unused_tile_id"), &TileSet::get_last_unused_tile_id);
ClassDB::bind_method(D_METHOD("find_tile_by_name", "name"), &TileSet::find_tile_by_name);
Fixes method definitions with extra number of arguments
2017-08-09 19:54:55 +08:00
ClassDB::bind_method(D_METHOD("get_tiles_ids"), &TileSet::_get_tiles_ids);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
Fix wrong return value in some virtual method bindings
2017-12-10 22:10:54 +08:00
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_is_tile_bound", PropertyInfo(Variant::INT, "drawn_id"), PropertyInfo(Variant::INT, "neighbor_id")));
BIND_VMETHOD(MethodInfo(Variant::VECTOR2, "_forward_subtile_selection", PropertyInfo(Variant::INT, "autotile_id"), PropertyInfo(Variant::INT, "bitmask"), PropertyInfo(Variant::OBJECT, "tilemap", PROPERTY_HINT_NONE, "TileMap"), PropertyInfo(Variant::VECTOR2, "tile_location")));
Add EDITMODE_PRIORITY for ATLAS_TILE When editing ATLAS_TILE, now it's possible to enable priority to randomize subtiles.
2018-12-23 21:06:53 +08:00
BIND_VMETHOD(MethodInfo(Variant::VECTOR2, "_forward_atlas_subtile_selection", PropertyInfo(Variant::INT, "atlastile_id"), PropertyInfo(Variant::OBJECT, "tilemap", PROPERTY_HINT_NONE, "TileMap"), PropertyInfo(Variant::VECTOR2, "tile_location")));
Implement auto-tiling
2017-10-22 09:42:23 +08:00
BIND_ENUM_CONSTANT(BITMASK_2X2);
Restore support for minimal 3x3 autotile sets
2018-05-17 11:39:43 +08:00
BIND_ENUM_CONSTANT(BITMASK_3X3_MINIMAL);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
BIND_ENUM_CONSTANT(BITMASK_3X3);
BIND_ENUM_CONSTANT(BIND_TOPLEFT);
BIND_ENUM_CONSTANT(BIND_TOP);
BIND_ENUM_CONSTANT(BIND_TOPRIGHT);
BIND_ENUM_CONSTANT(BIND_LEFT);
Added binding for Autotile Center
2020-01-27 22:07:32 +08:00
BIND_ENUM_CONSTANT(BIND_CENTER);
Implement auto-tiling
2017-10-22 09:42:23 +08:00
BIND_ENUM_CONSTANT(BIND_RIGHT);
BIND_ENUM_CONSTANT(BIND_BOTTOMLEFT);
BIND_ENUM_CONSTANT(BIND_BOTTOM);
BIND_ENUM_CONSTANT(BIND_BOTTOMRIGHT);
expose Tileset TileMode to GDScript
2018-04-09 04:54:02 +08:00
BIND_ENUM_CONSTANT(SINGLE_TILE);
BIND_ENUM_CONSTANT(AUTO_TILE);
New TileSet Editor
2018-07-30 05:54:12 +08:00
BIND_ENUM_CONSTANT(ATLAS_TILE);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
TileSet::TileSet() {
}
Reference in New Issue Copy Permalink