Codebase Browser
godot
Go to App

godot/scene/resources/2d/tile_set.cpp 

/**************************************************************************/
/*  tile_set.cpp                                                          */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* 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.                 */
/**************************************************************************/

#include "tile_set.h"
#include "tile_set.compat.inc"

#include "core/io/marshalls.h"
#include "core/math/geometry_2d.h"
#include "core/templates/local_vector.h"
#include "core/templates/rb_set.h"
#include "scene/gui/control.h"
#include "scene/resources/image_texture.h"
#include "servers/navigation_server_2d.h"

/////////////////////////////// TileMapPattern //////////////////////////////////////

void TileMapPattern::_set_tile_data(const Vector<int> &p_data) { … }

Vector<int> TileMapPattern::_get_tile_data() const { … }

void TileMapPattern::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) { … }

bool TileMapPattern::has_cell(const Vector2i &p_coords) const { … }

void TileMapPattern::remove_cell(const Vector2i &p_coords, bool p_update_size) { … }

int TileMapPattern::get_cell_source_id(const Vector2i &p_coords) const { … }

Vector2i TileMapPattern::get_cell_atlas_coords(const Vector2i &p_coords) const { … }

int TileMapPattern::get_cell_alternative_tile(const Vector2i &p_coords) const { … }

TypedArray<Vector2i> TileMapPattern::get_used_cells() const { … }

Size2i TileMapPattern::get_size() const { … }

void TileMapPattern::set_size(const Size2i &p_size) { … }

bool TileMapPattern::is_empty() const {
	return pattern.is_empty();
};

void TileMapPattern::clear() {
	size = Size2i();
	pattern.clear();
	emit_changed();
};

bool TileMapPattern::_set(const StringName &p_name, const Variant &p_value) { … }

bool TileMapPattern::_get(const StringName &p_name, Variant &r_ret) const { … }

void TileMapPattern::_get_property_list(List<PropertyInfo> *p_list) const { … }

void TileMapPattern::_bind_methods() { … }

/////////////////////////////// TileSet //////////////////////////////////////

bool TileSet::TerrainsPattern::is_valid() const { … }

bool TileSet::TerrainsPattern::is_erase_pattern() const { … }

bool TileSet::TerrainsPattern::operator<(const TerrainsPattern &p_terrains_pattern) const { … }

bool TileSet::TerrainsPattern::operator==(const TerrainsPattern &p_terrains_pattern) const { … }

void TileSet::TerrainsPattern::set_terrain(int p_terrain) { … }

int TileSet::TerrainsPattern::get_terrain() const { … }

void TileSet::TerrainsPattern::set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain) { … }

int TileSet::TerrainsPattern::get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const { … }

void TileSet::TerrainsPattern::from_array(Array p_terrains) { … }

Array TileSet::TerrainsPattern::as_array() const { … }

TileSet::TerrainsPattern::TerrainsPattern(const TileSet *p_tile_set, int p_terrain_set) { … }

const int TileSet::INVALID_SOURCE = …;

const char *TileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[] = …;

// -- Shape and layout --
void TileSet::set_tile_shape(TileSet::TileShape p_shape) { … }
TileSet::TileShape TileSet::get_tile_shape() const { … }

void TileSet::set_tile_layout(TileSet::TileLayout p_layout) { … }
TileSet::TileLayout TileSet::get_tile_layout() const { … }

void TileSet::set_tile_offset_axis(TileSet::TileOffsetAxis p_alignment) { … }
TileSet::TileOffsetAxis TileSet::get_tile_offset_axis() const { … }

void TileSet::set_tile_size(Size2i p_size) { … }
Size2i TileSet::get_tile_size() const { … }

int TileSet::get_next_source_id() const { … }

void TileSet::_update_terrains_cache() { … }

void TileSet::_compute_next_source_id() { … }

// Sources management
int TileSet::add_source(Ref<TileSetSource> p_tile_set_source, int p_atlas_source_id_override) { … }

void TileSet::remove_source(int p_source_id) { … }

void TileSet::remove_source_ptr(TileSetSource *p_tile_set_source) { … }

void TileSet::set_source_id(int p_source_id, int p_new_source_id) { … }

bool TileSet::has_source(int p_source_id) const { … }

Ref<TileSetSource> TileSet::get_source(int p_source_id) const { … }

int TileSet::get_source_count() const { … }

int TileSet::get_source_id(int p_index) const { … }

// Rendering
void TileSet::set_uv_clipping(bool p_uv_clipping) { … }

bool TileSet::is_uv_clipping() const {
	return uv_clipping;
};

int TileSet::get_occlusion_layers_count() const {
	return occlusion_layers.size();
};

void TileSet::add_occlusion_layer(int p_index) { … }

void TileSet::move_occlusion_layer(int p_from_index, int p_to_pos) { … }

void TileSet::remove_occlusion_layer(int p_index) { … }

void TileSet::set_occlusion_layer_light_mask(int p_layer_index, int p_light_mask) { … }

int TileSet::get_occlusion_layer_light_mask(int p_layer_index) const { … }

void TileSet::set_occlusion_layer_sdf_collision(int p_layer_index, bool p_sdf_collision) { … }

bool TileSet::get_occlusion_layer_sdf_collision(int p_layer_index) const { … }

int TileSet::get_physics_layers_count() const { … }

void TileSet::add_physics_layer(int p_index) { … }

void TileSet::move_physics_layer(int p_from_index, int p_to_pos) { … }

void TileSet::remove_physics_layer(int p_index) { … }

void TileSet::set_physics_layer_collision_layer(int p_layer_index, uint32_t p_layer) { … }

uint32_t TileSet::get_physics_layer_collision_layer(int p_layer_index) const { … }

void TileSet::set_physics_layer_collision_mask(int p_layer_index, uint32_t p_mask) { … }

uint32_t TileSet::get_physics_layer_collision_mask(int p_layer_index) const { … }

void TileSet::set_physics_layer_physics_material(int p_layer_index, Ref<PhysicsMaterial> p_physics_material) { … }

Ref<PhysicsMaterial> TileSet::get_physics_layer_physics_material(int p_layer_index) const { … }

// Terrains
int TileSet::get_terrain_sets_count() const { … }

void TileSet::add_terrain_set(int p_index) { … }

void TileSet::move_terrain_set(int p_from_index, int p_to_pos) { … }

void TileSet::remove_terrain_set(int p_index) { … }

void TileSet::set_terrain_set_mode(int p_terrain_set, TerrainMode p_terrain_mode) { … }

TileSet::TerrainMode TileSet::get_terrain_set_mode(int p_terrain_set) const { … }

int TileSet::get_terrains_count(int p_terrain_set) const { … }

void TileSet::add_terrain(int p_terrain_set, int p_index) { … }

void TileSet::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) { … }

void TileSet::remove_terrain(int p_terrain_set, int p_index) { … }

void TileSet::set_terrain_name(int p_terrain_set, int p_terrain_index, String p_name) { … }

String TileSet::get_terrain_name(int p_terrain_set, int p_terrain_index) const { … }

void TileSet::set_terrain_color(int p_terrain_set, int p_terrain_index, Color p_color) { … }

Color TileSet::get_terrain_color(int p_terrain_set, int p_terrain_index) const { … }

bool TileSet::is_valid_terrain_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode, TileSet::CellNeighbor p_peering_bit) const { … }

bool TileSet::is_valid_terrain_peering_bit(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const { … }

// Navigation
int TileSet::get_navigation_layers_count() const { … }

void TileSet::add_navigation_layer(int p_index) { … }

void TileSet::move_navigation_layer(int p_from_index, int p_to_pos) { … }

void TileSet::remove_navigation_layer(int p_index) { … }

void TileSet::set_navigation_layer_layers(int p_layer_index, uint32_t p_layers) { … }

uint32_t TileSet::get_navigation_layer_layers(int p_layer_index) const { … }

void TileSet::set_navigation_layer_layer_value(int p_layer_index, int p_layer_number, bool p_value) { … }

bool TileSet::get_navigation_layer_layer_value(int p_layer_index, int p_layer_number) const { … }

// Custom data.
int TileSet::get_custom_data_layers_count() const { … }

void TileSet::add_custom_data_layer(int p_index) { … }

void TileSet::move_custom_data_layer(int p_from_index, int p_to_pos) { … }

void TileSet::remove_custom_data_layer(int p_index) { … }

int TileSet::get_custom_data_layer_by_name(String p_value) const { … }

void TileSet::set_custom_data_layer_name(int p_layer_id, String p_value) { … }

String TileSet::get_custom_data_layer_name(int p_layer_id) const { … }

void TileSet::set_custom_data_layer_type(int p_layer_id, Variant::Type p_value) { … }

Variant::Type TileSet::get_custom_data_layer_type(int p_layer_id) const { … }

void TileSet::set_source_level_tile_proxy(int p_source_from, int p_source_to) { … }

int TileSet::get_source_level_tile_proxy(int p_source_from) { … }

bool TileSet::has_source_level_tile_proxy(int p_source_from) { … }

void TileSet::remove_source_level_tile_proxy(int p_source_from) { … }

void TileSet::set_coords_level_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_source_to, Vector2i p_coords_to) { … }

Array TileSet::get_coords_level_tile_proxy(int p_source_from, Vector2i p_coords_from) { … }

bool TileSet::has_coords_level_tile_proxy(int p_source_from, Vector2i p_coords_from) { … }

void TileSet::remove_coords_level_tile_proxy(int p_source_from, Vector2i p_coords_from) { … }

void TileSet::set_alternative_level_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_alternative_from, int p_source_to, Vector2i p_coords_to, int p_alternative_to) { … }

Array TileSet::get_alternative_level_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_alternative_from) { … }

bool TileSet::has_alternative_level_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_alternative_from) { … }

void TileSet::remove_alternative_level_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_alternative_from) { … }

Array TileSet::get_source_level_tile_proxies() const { … }

Array TileSet::get_coords_level_tile_proxies() const { … }

Array TileSet::get_alternative_level_tile_proxies() const { … }

Array TileSet::map_tile_proxy(int p_source_from, Vector2i p_coords_from, int p_alternative_from) const { … }

void TileSet::cleanup_invalid_tile_proxies() { … }

void TileSet::clear_tile_proxies() { … }

int TileSet::add_pattern(Ref<TileMapPattern> p_pattern, int p_index) { … }

Ref<TileMapPattern> TileSet::get_pattern(int p_index) { … }

void TileSet::remove_pattern(int p_index) { … }

int TileSet::get_patterns_count() { … }

RBSet<TileSet::TerrainsPattern> TileSet::get_terrains_pattern_set(int p_terrain_set) { … }

RBSet<TileMapCell> TileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) { … }

TileMapCell TileSet::get_random_tile_from_terrains_pattern(int p_terrain_set, TileSet::TerrainsPattern p_terrain_tile_pattern) { … }

Vector<Vector2> TileSet::get_tile_shape_polygon() const { … }

void TileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled, Ref<Texture2D> p_texture) const { … }

Vector2 TileSet::map_to_local(const Vector2i &p_pos) const { … }

Vector2i TileSet::local_to_map(const Vector2 &p_local_position) const { … }

bool TileSet::is_existing_neighbor(TileSet::CellNeighbor p_cell_neighbor) const { … }

Vector2i TileSet::get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const { … }

TypedArray<Vector2i> TileSet::get_surrounding_cells(const Vector2i &p_coords) const { … }

Vector2i TileSet::map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<TileMapPattern> p_pattern) const { … }

void TileSet::draw_cells_outline(CanvasItem *p_canvas_item, const RBSet<Vector2i> &p_cells, Color p_color, Transform2D p_transform) const { … }

Vector<Point2> TileSet::get_terrain_polygon(int p_terrain_set) { … }

Vector<Point2> TileSet::get_terrain_peering_bit_polygon(int p_terrain_set, TileSet::CellNeighbor p_bit) { … }

#define TERRAIN_ALPHA …

void TileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, const TileData *p_tile_data) { … }

Vector<Vector<Ref<Texture2D>>> TileSet::generate_terrains_icons(Size2i p_size) { … }

void TileSet::_source_changed() { … }

Vector<Point2> TileSet::_get_square_terrain_polygon(Vector2i p_size) { … }

Vector<Point2> TileSet::_get_square_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_square_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_square_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_isometric_terrain_polygon(Vector2i p_size) { … }

Vector<Point2> TileSet::_get_isometric_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_isometric_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_isometric_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_half_offset_terrain_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) { … }

Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_half_offset_corner_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) { … }

Vector<Point2> TileSet::_get_half_offset_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) { … }

void TileSet::reset_state() { … }

Vector2i TileSet::transform_coords_layout(const Vector2i &p_coords, TileSet::TileOffsetAxis p_offset_axis, TileSet::TileLayout p_from_layout, TileSet::TileLayout p_to_layout) { … }

const Vector2i TileSetSource::INVALID_ATLAS_COORDS = …;
const int TileSetSource::INVALID_TILE_ALTERNATIVE = …;

#ifndef DISABLE_DEPRECATED
void TileSet::_compatibility_conversion() { … }

Array TileSet::compatibility_tilemap_map(int p_tile_id, Vector2i p_coords, bool p_flip_h, bool p_flip_v, bool p_transpose) {
	Array cannot_convert_array;
	cannot_convert_array.push_back(TileSet::INVALID_SOURCE);
	cannot_convert_array.push_back(TileSetAtlasSource::INVALID_ATLAS_COORDS);
	cannot_convert_array.push_back(TileSetAtlasSource::INVALID_TILE_ALTERNATIVE);

	if (!compatibility_tilemap_mapping.has(p_tile_id)) {
		return cannot_convert_array;
	}

	int tile_mode = compatibility_tilemap_mapping_tile_modes[p_tile_id];
	switch (tile_mode) {
		case COMPATIBILITY_TILE_MODE_SINGLE_TILE: {
			Array a;
			a.push_back(p_flip_h);
			a.push_back(p_flip_v);
			a.push_back(p_transpose);
			return compatibility_tilemap_mapping[p_tile_id][a];
		}
		case COMPATIBILITY_TILE_MODE_AUTO_TILE:
			return cannot_convert_array;
			break;
		case COMPATIBILITY_TILE_MODE_ATLAS_TILE: {
			Array a;
			a.push_back(p_coords);
			a.push_back(p_flip_h);
			a.push_back(p_flip_v);
			a.push_back(p_transpose);
			return compatibility_tilemap_mapping[p_tile_id][a];
		}
		default:
			return cannot_convert_array;
			break;
	}
};

#endif // DISABLE_DEPRECATED

bool TileSet::_set(const StringName &p_name, const Variant &p_value) { … }

bool TileSet::_get(const StringName &p_name, Variant &r_ret) const { … }

void TileSet::_get_property_list(List<PropertyInfo> *p_list) const { … }

void TileSet::_validate_property(PropertyInfo &p_property) const { … }

void TileSet::_bind_methods() { … }

TileSet::TileSet() { … }

TileSet::~TileSet() { … }

/////////////////////////////// TileSetSource //////////////////////////////////////

void TileSetSource::set_tile_set(const TileSet *p_tile_set) { … }

TileSet *TileSetSource::get_tile_set() const { … }

void TileSetSource::reset_state() {
	tile_set = nullptr;
};

void TileSetSource::_bind_methods() { … }

/////////////////////////////// TileSetAtlasSource //////////////////////////////////////

void TileSetAtlasSource::set_tile_set(const TileSet *p_tile_set) { … }

const TileSet *TileSetAtlasSource::get_tile_set() const { … }

void TileSetAtlasSource::notify_tile_data_properties_should_change() { … }

void TileSetAtlasSource::add_occlusion_layer(int p_to_pos) { … }

void TileSetAtlasSource::move_occlusion_layer(int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_occlusion_layer(int p_index) { … }

void TileSetAtlasSource::add_physics_layer(int p_to_pos) { … }

void TileSetAtlasSource::move_physics_layer(int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_physics_layer(int p_index) { … }

void TileSetAtlasSource::add_terrain_set(int p_to_pos) { … }

void TileSetAtlasSource::move_terrain_set(int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_terrain_set(int p_index) { … }

void TileSetAtlasSource::add_terrain(int p_terrain_set, int p_to_pos) { … }

void TileSetAtlasSource::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_terrain(int p_terrain_set, int p_index) { … }

void TileSetAtlasSource::add_navigation_layer(int p_to_pos) { … }

void TileSetAtlasSource::move_navigation_layer(int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_navigation_layer(int p_index) { … }

void TileSetAtlasSource::add_custom_data_layer(int p_to_pos) { … }

void TileSetAtlasSource::move_custom_data_layer(int p_from_index, int p_to_pos) { … }

void TileSetAtlasSource::remove_custom_data_layer(int p_index) { … }

void TileSetAtlasSource::reset_state() { … }

void TileSetAtlasSource::set_texture(Ref<Texture2D> p_texture) { … }

Ref<Texture2D> TileSetAtlasSource::get_texture() const { … }

void TileSetAtlasSource::set_margins(Vector2i p_margins) { … }

Vector2i TileSetAtlasSource::get_margins() const { … }

void TileSetAtlasSource::set_separation(Vector2i p_separation) { … }

Vector2i TileSetAtlasSource::get_separation() const { … }

void TileSetAtlasSource::set_texture_region_size(Vector2i p_tile_size) { … }

Vector2i TileSetAtlasSource::get_texture_region_size() const { … }

void TileSetAtlasSource::set_use_texture_padding(bool p_use_padding) { … }

bool TileSetAtlasSource::get_use_texture_padding() const { … }

Vector2i TileSetAtlasSource::get_atlas_grid_size() const { … }

bool TileSetAtlasSource::_set(const StringName &p_name, const Variant &p_value) { … }

bool TileSetAtlasSource::_get(const StringName &p_name, Variant &r_ret) const { … }

void TileSetAtlasSource::_get_property_list(List<PropertyInfo> *p_list) const { … }

void TileSetAtlasSource::create_tile(const Vector2i p_atlas_coords, const Vector2i p_size) { … }

void TileSetAtlasSource::remove_tile(Vector2i p_atlas_coords) { … }

bool TileSetAtlasSource::has_tile(Vector2i p_atlas_coords) const { … }

Vector2i TileSetAtlasSource::get_tile_at_coords(Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_columns(const Vector2i p_atlas_coords, int p_frame_columns) { … }

int TileSetAtlasSource::get_tile_animation_columns(const Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_separation(const Vector2i p_atlas_coords, const Vector2i p_separation) { … }

Vector2i TileSetAtlasSource::get_tile_animation_separation(const Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_speed(const Vector2i p_atlas_coords, real_t p_speed) { … }

real_t TileSetAtlasSource::get_tile_animation_speed(const Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_mode(const Vector2i p_atlas_coords, TileSetAtlasSource::TileAnimationMode p_mode) { … }

TileSetAtlasSource::TileAnimationMode TileSetAtlasSource::get_tile_animation_mode(const Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_frames_count(const Vector2i p_atlas_coords, int p_frames_count) { … }

int TileSetAtlasSource::get_tile_animation_frames_count(const Vector2i p_atlas_coords) const { … }

void TileSetAtlasSource::set_tile_animation_frame_duration(const Vector2i p_atlas_coords, int p_frame_index, real_t p_duration) { … }

real_t TileSetAtlasSource::get_tile_animation_frame_duration(const Vector2i p_atlas_coords, int p_frame_index) const { … }

real_t TileSetAtlasSource::get_tile_animation_total_duration(const Vector2i p_atlas_coords) const { … }

Vector2i TileSetAtlasSource::get_tile_size_in_atlas(Vector2i p_atlas_coords) const { … }

int TileSetAtlasSource::get_tiles_count() const { … }

Vector2i TileSetAtlasSource::get_tile_id(int p_index) const { … }

bool TileSetAtlasSource::has_room_for_tile(Vector2i p_atlas_coords, Vector2i p_size, int p_animation_columns, Vector2i p_animation_separation, int p_frames_count, Vector2i p_ignored_tile) const { … }

bool TileSetAtlasSource::has_tiles_outside_texture() const { … }

Vector<Vector2i> TileSetAtlasSource::get_tiles_outside_texture() const { … }

void TileSetAtlasSource::clear_tiles_outside_texture() { … }

PackedVector2Array TileSetAtlasSource::get_tiles_to_be_removed_on_change(Ref<Texture2D> p_texture, Vector2i p_margins, Vector2i p_separation, Vector2i p_texture_region_size) { … }

Rect2i TileSetAtlasSource::get_tile_texture_region(Vector2i p_atlas_coords, int p_frame) const { … }

bool TileSetAtlasSource::is_position_in_tile_texture_region(const Vector2i p_atlas_coords, int p_alternative_tile, Vector2 p_position) const { … }

bool TileSetAtlasSource::is_rect_in_tile_texture_region(const Vector2i p_atlas_coords, int p_alternative_tile, Rect2 p_rect) const { … }

int TileSetAtlasSource::alternative_no_transform(int p_alternative_id) { … }

// Getters for texture and tile region (padded or not)
Ref<Texture2D> TileSetAtlasSource::get_runtime_texture() const { … }

Rect2i TileSetAtlasSource::get_runtime_tile_texture_region(Vector2i p_atlas_coords, int p_frame) const { … }

void TileSetAtlasSource::move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords, Vector2i p_new_size) { … }

int TileSetAtlasSource::create_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_id_override) { … }

void TileSetAtlasSource::remove_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) { … }

void TileSetAtlasSource::set_alternative_tile_id(const Vector2i p_atlas_coords, int p_alternative_tile, int p_new_id) { … }

bool TileSetAtlasSource::has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const { … }

int TileSetAtlasSource::get_next_alternative_tile_id(const Vector2i p_atlas_coords) const { … }

int TileSetAtlasSource::get_alternative_tiles_count(const Vector2i p_atlas_coords) const { … }

int TileSetAtlasSource::get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const { … }

TileData *TileSetAtlasSource::get_tile_data(const Vector2i p_atlas_coords, int p_alternative_tile) const { … }

void TileSetAtlasSource::_notification(int p_notification) { … }

void TileSetAtlasSource::_bind_methods() { … }

TileSetAtlasSource::~TileSetAtlasSource() { … }

TileData *TileSetAtlasSource::_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) { … }

const TileData *TileSetAtlasSource::_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) const { … }

void TileSetAtlasSource::_compute_next_alternative_id(const Vector2i p_atlas_coords) { … }

void TileSetAtlasSource::_clear_coords_mapping_cache(Vector2i p_atlas_coords) { … }

void TileSetAtlasSource::_create_coords_mapping_cache(Vector2i p_atlas_coords) { … }

void TileSetAtlasSource::_queue_update_padded_texture() { … }

Ref<ImageTexture> TileSetAtlasSource::_create_padded_image_texture(const Ref<Texture2D> &p_source) { … }

void TileSetAtlasSource::_update_padded_texture() { … }

void TileSetAtlasSource::_try_emit_changed() { … }

/////////////////////////////// TileSetScenesCollectionSource //////////////////////////////////////

void TileSetScenesCollectionSource::_compute_next_alternative_id() { … }

void TileSetScenesCollectionSource::_try_emit_changed() { … }

int TileSetScenesCollectionSource::get_tiles_count() const { … }

Vector2i TileSetScenesCollectionSource::get_tile_id(int p_tile_index) const { … }

bool TileSetScenesCollectionSource::has_tile(Vector2i p_atlas_coords) const { … }

int TileSetScenesCollectionSource::get_alternative_tiles_count(const Vector2i p_atlas_coords) const { … }

int TileSetScenesCollectionSource::get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const { … }

bool TileSetScenesCollectionSource::has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const { … }

int TileSetScenesCollectionSource::create_scene_tile(Ref<PackedScene> p_packed_scene, int p_id_override) { … }

void TileSetScenesCollectionSource::set_scene_tile_id(int p_id, int p_new_id) { … }

void TileSetScenesCollectionSource::set_scene_tile_scene(int p_id, Ref<PackedScene> p_packed_scene) { … }

Ref<PackedScene> TileSetScenesCollectionSource::get_scene_tile_scene(int p_id) const { … }

void TileSetScenesCollectionSource::set_scene_tile_display_placeholder(int p_id, bool p_display_placeholder) { … }

bool TileSetScenesCollectionSource::get_scene_tile_display_placeholder(int p_id) const { … }

void TileSetScenesCollectionSource::remove_scene_tile(int p_id) { … }

int TileSetScenesCollectionSource::get_next_scene_tile_id() const { … }

bool TileSetScenesCollectionSource::_set(const StringName &p_name, const Variant &p_value) { … }

bool TileSetScenesCollectionSource::_get(const StringName &p_name, Variant &r_ret) const { … }

void TileSetScenesCollectionSource::_get_property_list(List<PropertyInfo> *p_list) const { … }

void TileSetScenesCollectionSource::_notification(int p_notification) { … }

void TileSetScenesCollectionSource::_bind_methods() { … }

/////////////////////////////// TileData //////////////////////////////////////

void TileData::set_tile_set(const TileSet *p_tile_set) { … }

void TileData::notify_tile_data_properties_should_change() { … }

void TileData::add_occlusion_layer(int p_to_pos) { … }

void TileData::move_occlusion_layer(int p_from_index, int p_to_pos) { … }

void TileData::remove_occlusion_layer(int p_index) { … }

void TileData::add_physics_layer(int p_to_pos) { … }

void TileData::move_physics_layer(int p_from_index, int p_to_pos) { … }

void TileData::remove_physics_layer(int p_index) { … }

void TileData::add_terrain_set(int p_to_pos) { … }

void TileData::move_terrain_set(int p_from_index, int p_to_pos) { … }

void TileData::remove_terrain_set(int p_index) { … }

void TileData::add_terrain(int p_terrain_set, int p_to_pos) { … }

void TileData::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) { … }

void TileData::remove_terrain(int p_terrain_set, int p_index) { … }

void TileData::add_navigation_layer(int p_to_pos) { … }

void TileData::move_navigation_layer(int p_from_index, int p_to_pos) { … }

void TileData::remove_navigation_layer(int p_index) { … }

void TileData::add_custom_data_layer(int p_to_pos) { … }

void TileData::move_custom_data_layer(int p_from_index, int p_to_pos) { … }

void TileData::remove_custom_data_layer(int p_index) { … }

void TileData::set_allow_transform(bool p_allow_transform) { … }

bool TileData::is_allowing_transform() const { … }

TileData *TileData::duplicate() { … }

// Rendering
void TileData::set_flip_h(bool p_flip_h) { … }
bool TileData::get_flip_h() const { … }

void TileData::set_flip_v(bool p_flip_v) { … }

bool TileData::get_flip_v() const { … }

void TileData::set_transpose(bool p_transpose) { … }
bool TileData::get_transpose() const { … }

void TileData::set_texture_origin(Vector2i p_texture_origin) { … }

Vector2i TileData::get_texture_origin() const { … }

void TileData::set_material(Ref<Material> p_material) { … }
Ref<Material> TileData::get_material() const { … }

void TileData::set_modulate(Color p_modulate) { … }
Color TileData::get_modulate() const { … }

void TileData::set_z_index(int p_z_index) { … }
int TileData::get_z_index() const { … }

void TileData::set_y_sort_origin(int p_y_sort_origin) { … }
int TileData::get_y_sort_origin() const { … }

#ifndef DISABLE_DEPRECATED
void TileData::set_occluder(int p_layer_id, Ref<OccluderPolygon2D> p_occluder_polygon) { … }

Ref<OccluderPolygon2D> TileData::get_occluder(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const { … }
#endif // DISABLE_DEPRECATED

void TileData::set_occluder_polygons_count(int p_layer_id, int p_polygons_count) { … }

int TileData::get_occluder_polygons_count(int p_layer_id) const { … }

void TileData::add_occluder_polygon(int p_layer_id) { … }

void TileData::remove_occluder_polygon(int p_layer_id, int p_polygon_index) { … }

void TileData::set_occluder_polygon(int p_layer_id, int p_polygon_index, const Ref<OccluderPolygon2D> &p_occluder_polygon) { … }

Ref<OccluderPolygon2D> TileData::get_occluder_polygon(int p_layer_id, int p_polygon_index, bool p_flip_h, bool p_flip_v, bool p_transpose) const { … }

// Physics
void TileData::set_constant_linear_velocity(int p_layer_id, const Vector2 &p_velocity) { … }

Vector2 TileData::get_constant_linear_velocity(int p_layer_id) const { … }

void TileData::set_constant_angular_velocity(int p_layer_id, real_t p_velocity) { … }

real_t TileData::get_constant_angular_velocity(int p_layer_id) const { … }

void TileData::set_collision_polygons_count(int p_layer_id, int p_polygons_count) { … }

int TileData::get_collision_polygons_count(int p_layer_id) const { … }

void TileData::add_collision_polygon(int p_layer_id) { … }

void TileData::remove_collision_polygon(int p_layer_id, int p_polygon_index) { … }

void TileData::set_collision_polygon_points(int p_layer_id, int p_polygon_index, Vector<Vector2> p_polygon) { … }

Vector<Vector2> TileData::get_collision_polygon_points(int p_layer_id, int p_polygon_index) const { … }

void TileData::set_collision_polygon_one_way(int p_layer_id, int p_polygon_index, bool p_one_way) { … }

bool TileData::is_collision_polygon_one_way(int p_layer_id, int p_polygon_index) const { … }

void TileData::set_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index, float p_one_way_margin) { … }

float TileData::get_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index) const { … }

int TileData::get_collision_polygon_shapes_count(int p_layer_id, int p_polygon_index) const { … }

Ref<ConvexPolygonShape2D> TileData::get_collision_polygon_shape(int p_layer_id, int p_polygon_index, int shape_index, bool p_flip_h, bool p_flip_v, bool p_transpose) const { … }

// Terrain
void TileData::set_terrain_set(int p_terrain_set) { … }

int TileData::get_terrain_set() const { … }

void TileData::set_terrain(int p_terrain) { … }

int TileData::get_terrain() const { … }

void TileData::set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain_index) { … }

int TileData::get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const { … }

bool TileData::is_valid_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const { … }

TileSet::TerrainsPattern TileData::get_terrains_pattern() const { … }

// Navigation
void TileData::set_navigation_polygon(int p_layer_id, Ref<NavigationPolygon> p_navigation_polygon) { … }

Ref<NavigationPolygon> TileData::get_navigation_polygon(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const { … }

// Misc
void TileData::set_probability(float p_probability) { … }
float TileData::get_probability() const { … }

// Custom data
void TileData::set_custom_data(String p_layer_name, Variant p_value) { … }

Variant TileData::get_custom_data(String p_layer_name) const { … }

void TileData::set_custom_data_by_layer_id(int p_layer_id, Variant p_value) { … }

Variant TileData::get_custom_data_by_layer_id(int p_layer_id) const { … }

PackedVector2Array TileData::get_transformed_vertices(const PackedVector2Array &p_vertices, bool p_flip_h, bool p_flip_v, bool p_transpose) { … }

bool TileData::_set(const StringName &p_name, const Variant &p_value) { … }

bool TileData::_get(const StringName &p_name, Variant &r_ret) const { … }

void TileData::_get_property_list(List<PropertyInfo> *p_list) const { … }

void TileData::_bind_methods() { … }