tile_map.cpp | Explore in Territory

/**************************************************************************/
/*  tile_map.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_map.h"
#include "tile_map.compat.inc"

#include "core/io/marshalls.h"
#include "scene/gui/control.h"

#define TILEMAP_CALL_FOR_LAYER …

#define TILEMAP_CALL_FOR_LAYER_V …

void TileMap::_tile_set_changed() { … }

void TileMap::_emit_changed() { … }

void TileMap::_set_tile_map_data_using_compatibility_format(int p_layer, TileMapDataFormat p_format, const Vector<int> &p_data) { … }

Vector<int> TileMap::_get_tile_map_data_using_compatibility_format(int p_layer) const { … }

void TileMap::_set_layer_tile_data(int p_layer, const PackedInt32Array &p_data) { … }

void TileMap::_notification(int p_what) { … }

#ifndef DISABLE_DEPRECATED
// Deprecated methods.
void TileMap::force_update(int p_layer) { … }
#endif // DISABLE_DEPRECATED

void TileMap::set_rendering_quadrant_size(int p_size) { … }

int TileMap::get_rendering_quadrant_size() const { … }

void TileMap::set_tileset(const Ref<TileSet> &p_tileset) { … }

Ref<TileSet> TileMap::get_tileset() const { … }

int TileMap::get_layers_count() const { … }

void TileMap::add_layer(int p_to_pos) { … }

void TileMap::move_layer(int p_layer, int p_to_pos) { … }

void TileMap::remove_layer(int p_layer) { … }

void TileMap::set_layer_name(int p_layer, String p_name) { … }

String TileMap::get_layer_name(int p_layer) const { … }

void TileMap::set_layer_enabled(int p_layer, bool p_enabled) { … }

bool TileMap::is_layer_enabled(int p_layer) const { … }

void TileMap::set_layer_modulate(int p_layer, Color p_modulate) { … }

Color TileMap::get_layer_modulate(int p_layer) const { … }

void TileMap::set_layer_y_sort_enabled(int p_layer, bool p_y_sort_enabled) { … }

bool TileMap::is_layer_y_sort_enabled(int p_layer) const { … }

void TileMap::set_layer_y_sort_origin(int p_layer, int p_y_sort_origin) { … }

int TileMap::get_layer_y_sort_origin(int p_layer) const { … }

void TileMap::set_layer_z_index(int p_layer, int p_z_index) { … }

int TileMap::get_layer_z_index(int p_layer) const { … }

void TileMap::set_layer_navigation_enabled(int p_layer, bool p_enabled) { … }

bool TileMap::is_layer_navigation_enabled(int p_layer) const { … }

void TileMap::set_layer_navigation_map(int p_layer, RID p_map) { … }

RID TileMap::get_layer_navigation_map(int p_layer) const { … }

void TileMap::set_collision_animatable(bool p_collision_animatable) { … }

bool TileMap::is_collision_animatable() const { … }

void TileMap::set_collision_visibility_mode(TileMap::VisibilityMode p_show_collision) { … }

TileMap::VisibilityMode TileMap::get_collision_visibility_mode() const { … }

void TileMap::set_navigation_visibility_mode(TileMap::VisibilityMode p_show_navigation) { … }

TileMap::VisibilityMode TileMap::get_navigation_visibility_mode() const { … }

void TileMap::set_y_sort_enabled(bool p_enable) { … }

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

void TileMap::erase_cell(int p_layer, const Vector2i &p_coords) { … }

int TileMap::get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

Vector2i TileMap::get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

int TileMap::get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

TileData *TileMap::get_cell_tile_data(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

bool TileMap::is_cell_flipped_h(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

bool TileMap::is_cell_flipped_v(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

bool TileMap::is_cell_transposed(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

Ref<TileMapPattern> TileMap::get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array) { … }

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

void TileMap::set_pattern(int p_layer, const Vector2i &p_position, const Ref<TileMapPattern> p_pattern) { … }

HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_constraints(int p_layer, const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> &p_constraints) { … }

HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { … }

HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_path(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { … }

HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains) { … }

void TileMap::set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { … }

void TileMap::set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { … }

TileMapCell TileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { … }

Vector2i TileMap::get_coords_for_body_rid(RID p_physics_body) { … }

int TileMap::get_layer_for_body_rid(RID p_physics_body) { … }

void TileMap::fix_invalid_tiles() { … }

#ifdef TOOLS_ENABLED
TileMapLayer *TileMap::duplicate_layer_from_internal(int p_layer) { … }
#endif // TOOLS_ENABLED

void TileMap::clear_layer(int p_layer) { … }

void TileMap::clear() { … }

void TileMap::update_internals() { … }

void TileMap::notify_runtime_tile_data_update(int p_layer) { … }

#ifdef DEBUG_ENABLED
Rect2 TileMap::_edit_get_rect() const { … }
#endif // DEBUG_ENABLED

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

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

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

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

Vector2i TileMap::local_to_map(const Vector2 &p_pos) const { … }

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

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

TypedArray<Vector2i> TileMap::get_used_cells(int p_layer) const { … }

TypedArray<Vector2i> TileMap::get_used_cells_by_id(int p_layer, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) const { … }

Rect2i TileMap::get_used_rect() const { … }

// --- Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems ---

void TileMap::set_light_mask(int p_light_mask) { … }

void TileMap::set_self_modulate(const Color &p_self_modulate) { … }

void TileMap::set_texture_filter(TextureFilter p_texture_filter) { … }

void TileMap::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) { … }

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

PackedStringArray TileMap::get_configuration_warnings() const { … }

void TileMap::_bind_methods() { … }

TileMap::TileMap() { … }

#undef TILEMAP_CALL_FOR_LAYER
#undef TILEMAP_CALL_FOR_LAYER_V
godot/scene/2d/tile_map.cpp
