2023-01-05 12:25:55 +00:00
/**************************************************************************/
/* tile_map.h */
/**************************************************************************/
/* 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. */
/**************************************************************************/
2018-01-04 23:50:27 +00:00
2014-02-10 01:10:30 +00:00
# ifndef TILE_MAP_H
# define TILE_MAP_H
# include "scene/2d/node_2d.h"
2021-05-07 13:41:39 +00:00
# include "scene/gui/control.h"
2014-02-10 01:10:30 +00:00
# include "scene/resources/tile_set.h"
2021-05-07 13:41:39 +00:00
class TileSetAtlasSource ;
2019-02-05 23:45:40 +00:00
2023-06-16 12:16:37 +00:00
class TerrainConstraint {
private :
const TileMap * tile_map = nullptr ;
Vector2i base_cell_coords ;
int bit = - 1 ;
int terrain = - 1 ;
int priority = 1 ;
public :
bool operator < ( const TerrainConstraint & p_other ) const {
if ( base_cell_coords = = p_other . base_cell_coords ) {
return bit < p_other . bit ;
}
return base_cell_coords < p_other . base_cell_coords ;
}
String to_string ( ) const {
return vformat ( " Constraint {pos:%s, bit:%d, terrain:%d, priority:%d} " , base_cell_coords , bit , terrain , priority ) ;
}
Vector2i get_base_cell_coords ( ) const {
return base_cell_coords ;
}
bool is_center_bit ( ) const {
return bit = = 0 ;
}
HashMap < Vector2i , TileSet : : CellNeighbor > get_overlapping_coords_and_peering_bits ( ) const ;
void set_terrain ( int p_terrain ) {
terrain = p_terrain ;
}
int get_terrain ( ) const {
return terrain ;
}
void set_priority ( int p_priority ) {
priority = p_priority ;
}
int get_priority ( ) const {
return priority ;
}
TerrainConstraint ( const TileMap * p_tile_map , const Vector2i & p_position , int p_terrain ) ; // For the center terrain bit
TerrainConstraint ( const TileMap * p_tile_map , const Vector2i & p_position , const TileSet : : CellNeighbor & p_bit , int p_terrain ) ; // For peering bits
TerrainConstraint ( ) { } ;
} ;
2023-08-24 11:31:14 +00:00
# ifdef DEBUG_ENABLED
class DebugQuadrant ;
# endif // DEBUG_ENABLED
class RenderingQuadrant ;
2021-05-07 13:41:39 +00:00
2023-08-24 11:31:14 +00:00
struct CellData {
2021-05-07 13:41:39 +00:00
Vector2i coords ;
2023-08-24 11:31:14 +00:00
TileMapCell cell ;
2021-05-07 13:41:39 +00:00
// Debug.
2023-08-24 11:31:14 +00:00
SelfList < CellData > debug_quadrant_list_element ;
2021-05-07 13:41:39 +00:00
2021-05-18 13:40:52 +00:00
// Rendering.
2023-08-24 11:31:14 +00:00
Ref < RenderingQuadrant > rendering_quadrant ;
SelfList < CellData > rendering_quadrant_list_element ;
List < RID > occluders ;
2021-05-07 13:41:39 +00:00
// Physics.
2023-08-24 11:31:14 +00:00
LocalVector < RID > bodies ;
2021-05-07 13:41:39 +00:00
2021-05-18 13:40:52 +00:00
// Navigation.
2023-08-24 11:31:14 +00:00
LocalVector < RID > navigation_regions ;
2021-05-07 13:41:39 +00:00
2021-05-18 13:40:52 +00:00
// Scenes.
2023-08-24 11:31:14 +00:00
String scene ;
2021-05-18 13:40:52 +00:00
2021-10-22 14:32:06 +00:00
// Runtime TileData cache.
2023-08-24 11:31:14 +00:00
TileData * runtime_tile_data_cache = nullptr ;
// List elements.
SelfList < CellData > dirty_list_element ;
// For those, copy everything but SelfList elements.
void operator = ( const CellData & p_other ) {
coords = p_other . coords ;
cell = p_other . cell ;
occluders = p_other . occluders ;
bodies = p_other . bodies ;
navigation_regions = p_other . navigation_regions ;
scene = p_other . scene ;
runtime_tile_data_cache = p_other . runtime_tile_data_cache ;
2021-05-07 13:41:39 +00:00
}
2023-08-24 11:31:14 +00:00
CellData ( const CellData & p_other ) :
debug_quadrant_list_element ( this ) ,
rendering_quadrant_list_element ( this ) ,
2021-05-07 13:41:39 +00:00
dirty_list_element ( this ) {
2023-08-24 11:31:14 +00:00
coords = p_other . coords ;
cell = p_other . cell ;
occluders = p_other . occluders ;
bodies = p_other . bodies ;
navigation_regions = p_other . navigation_regions ;
scene = p_other . scene ;
runtime_tile_data_cache = p_other . runtime_tile_data_cache ;
2021-05-07 13:41:39 +00:00
}
2023-08-24 11:31:14 +00:00
CellData ( ) :
debug_quadrant_list_element ( this ) ,
rendering_quadrant_list_element ( this ) ,
2021-05-07 13:41:39 +00:00
dirty_list_element ( this ) {
}
} ;
2019-07-08 09:35:52 +00:00
2023-08-24 11:31:14 +00:00
# ifdef DEBUG_ENABLED
class DebugQuadrant : public RefCounted {
GDCLASS ( DebugQuadrant , RefCounted ) ;
public :
Vector2i quadrant_coords ;
SelfList < CellData > : : List cells ;
RID canvas_item ;
SelfList < DebugQuadrant > dirty_quadrant_list_element ;
// For those, copy everything but SelfList elements.
DebugQuadrant ( const DebugQuadrant & p_other ) :
dirty_quadrant_list_element ( this ) {
quadrant_coords = p_other . quadrant_coords ;
cells = p_other . cells ;
canvas_item = p_other . canvas_item ;
}
DebugQuadrant ( ) :
dirty_quadrant_list_element ( this ) {
}
~ DebugQuadrant ( ) {
cells . clear ( ) ;
}
} ;
# endif // DEBUG_ENABLED
class RenderingQuadrant : public RefCounted {
GDCLASS ( RenderingQuadrant , RefCounted ) ;
public :
struct CoordsWorldComparator {
_ALWAYS_INLINE_ bool operator ( ) ( const Vector2 & p_a , const Vector2 & p_b ) const {
// We sort the cells by their local coords, as it is needed by rendering.
if ( p_a . y = = p_b . y ) {
return p_a . x > p_b . x ;
} else {
return p_a . y < p_b . y ;
}
}
} ;
Vector2i quadrant_coords ;
SelfList < CellData > : : List cells ;
List < RID > canvas_items ;
SelfList < RenderingQuadrant > dirty_quadrant_list_element ;
// For those, copy everything but SelfList elements.
RenderingQuadrant ( const RenderingQuadrant & p_other ) :
dirty_quadrant_list_element ( this ) {
quadrant_coords = p_other . quadrant_coords ;
cells = p_other . cells ;
canvas_items = p_other . canvas_items ;
}
RenderingQuadrant ( ) :
dirty_quadrant_list_element ( this ) {
}
~ RenderingQuadrant ( ) {
cells . clear ( ) ;
}
} ;
2023-06-16 12:16:37 +00:00
class TileMapLayer : public RefCounted {
2023-08-24 11:31:14 +00:00
GDCLASS ( TileMapLayer , RefCounted ) ;
2021-05-07 13:41:39 +00:00
public :
2023-06-16 12:16:37 +00:00
enum DataFormat {
FORMAT_1 = 0 ,
FORMAT_2 ,
FORMAT_3 ,
FORMAT_MAX ,
} ;
2021-10-21 14:42:06 +00:00
2023-08-24 11:31:14 +00:00
enum DirtyFlags {
DIRTY_FLAGS_LAYER_ENABLED = 0 ,
DIRTY_FLAGS_LAYER_MODULATE ,
DIRTY_FLAGS_LAYER_Y_SORT_ENABLED ,
DIRTY_FLAGS_LAYER_Y_SORT_ORIGIN ,
DIRTY_FLAGS_LAYER_Z_INDEX ,
DIRTY_FLAGS_LAYER_INDEX_IN_TILE_MAP_NODE ,
DIRTY_FLAGS_TILE_MAP_IN_TREE ,
DIRTY_FLAGS_TILE_MAP_IN_CANVAS ,
DIRTY_FLAGS_TILE_MAP_VISIBILITY ,
DIRTY_FLAGS_TILE_MAP_XFORM ,
DIRTY_FLAGS_TILE_MAP_LOCAL_XFORM ,
DIRTY_FLAGS_TILE_MAP_SELECTED_LAYER ,
DIRTY_FLAGS_TILE_MAP_LIGHT_MASK ,
DIRTY_FLAGS_TILE_MAP_MATERIAL ,
DIRTY_FLAGS_TILE_MAP_USE_PARENT_MATERIAL ,
DIRTY_FLAGS_TILE_MAP_TEXTURE_FILTER ,
DIRTY_FLAGS_TILE_MAP_TEXTURE_REPEAT ,
DIRTY_FLAGS_TILE_MAP_TILE_SET ,
DIRTY_FLAGS_TILE_MAP_QUADRANT_SIZE ,
DIRTY_FLAGS_TILE_MAP_COLLISION_ANIMATABLE ,
DIRTY_FLAGS_TILE_MAP_COLLISION_VISIBILITY_MODE ,
DIRTY_FLAGS_TILE_MAP_NAVIGATION_VISIBILITY_MODE ,
DIRTY_FLAGS_TILE_MAP_Y_SORT_ENABLED ,
DIRTY_FLAGS_TILE_MAP_RUNTIME_UPDATE ,
DIRTY_FLAGS_MAX ,
} ;
2023-06-16 12:16:37 +00:00
private :
// Exposed properties.
String name ;
bool enabled = true ;
Color modulate = Color ( 1 , 1 , 1 , 1 ) ;
bool y_sort_enabled = false ;
int y_sort_origin = 0 ;
int z_index = 0 ;
RID navigation_map ;
bool uses_world_navigation_map = false ;
// Internal.
TileMap * tile_map_node = nullptr ;
int layer_index_in_tile_map_node = - 1 ;
RID canvas_item ;
2023-08-24 11:31:14 +00:00
HashMap < Vector2i , CellData > tile_map ;
// Dirty flag. Allows knowing what was modified since the last update.
struct {
bool flags [ DIRTY_FLAGS_MAX ] = { false } ;
SelfList < CellData > : : List cell_list ;
} dirty ;
bool in_destructor = false ;
2023-06-16 12:16:37 +00:00
// Rect cache.
mutable Rect2 rect_cache ;
mutable bool rect_cache_dirty = true ;
mutable Rect2i used_rect_cache ;
mutable bool used_rect_cache_dirty = true ;
2023-08-24 11:31:14 +00:00
// Runtime tile data.
bool _runtime_update_tile_data_was_cleaned_up = false ;
void _build_runtime_update_tile_data ( ) ;
void _build_runtime_update_tile_data_for_cell ( CellData & r_cell_data , bool p_auto_add_to_dirty_list = false ) ;
void _clear_runtime_update_tile_data ( ) ;
2021-10-21 14:42:06 +00:00
2023-06-16 12:16:37 +00:00
// Per-system methods.
2023-08-24 11:31:14 +00:00
# ifdef DEBUG_ENABLED
HashMap < Vector2i , Ref < DebugQuadrant > > debug_quadrant_map ;
Vector2i _coords_to_debug_quadrant_coords ( const Vector2i & p_coords ) const ;
bool _debug_was_cleaned_up = false ;
void _debug_update ( ) ;
void _debug_quadrants_update_cell ( CellData & r_cell_data , SelfList < DebugQuadrant > : : List & r_dirty_debug_quadrant_list ) ;
# endif // DEBUG_ENABLED
HashMap < Vector2i , Ref < RenderingQuadrant > > rendering_quadrant_map ;
Vector2i _coords_to_rendering_quadrant_coords ( const Vector2i & p_coords ) const ;
bool _rendering_was_cleaned_up = false ;
2023-06-16 12:16:37 +00:00
void _rendering_update ( ) ;
2023-08-24 11:31:14 +00:00
void _rendering_quadrants_update_cell ( CellData & r_cell_data , SelfList < RenderingQuadrant > : : List & r_dirty_rendering_quadrant_list ) ;
void _rendering_occluders_clear_cell ( CellData & r_cell_data ) ;
void _rendering_occluders_update_cell ( CellData & r_cell_data ) ;
# ifdef DEBUG_ENABLED
void _rendering_draw_cell_debug ( const RID & p_canvas_item , const Vector2i & p_quadrant_pos , const CellData & r_cell_data ) ;
# endif // DEBUG_ENABLED
2021-10-21 14:42:06 +00:00
2023-06-16 12:16:37 +00:00
HashMap < RID , Vector2i > bodies_coords ; // Mapping for RID to coords.
2023-08-24 11:31:14 +00:00
bool _physics_was_cleaned_up = false ;
void _physics_update ( ) ;
void _physics_notify_tilemap_change ( DirtyFlags p_what ) ;
void _physics_clear_cell ( CellData & r_cell_data ) ;
void _physics_update_cell ( CellData & r_cell_data ) ;
# ifdef DEBUG_ENABLED
void _physics_draw_cell_debug ( const RID & p_canvas_item , const Vector2i & p_quadrant_pos , const CellData & r_cell_data ) ;
# endif // DEBUG_ENABLED
bool _navigation_was_cleaned_up = false ;
2023-06-16 12:16:37 +00:00
void _navigation_update ( ) ;
2023-08-24 11:31:14 +00:00
void _navigation_clear_cell ( CellData & r_cell_data ) ;
void _navigation_update_cell ( CellData & r_cell_data ) ;
# ifdef DEBUG_ENABLED
void _navigation_draw_cell_debug ( const RID & p_canvas_item , const Vector2i & p_quadrant_pos , const CellData & r_cell_data ) ;
# endif // DEBUG_ENABLED
bool _scenes_was_cleaned_up = false ;
void _scenes_update ( ) ;
void _scenes_clear_cell ( CellData & r_cell_data ) ;
void _scenes_update_cell ( CellData & r_cell_data ) ;
# ifdef DEBUG_ENABLED
void _scenes_draw_cell_debug ( const RID & p_canvas_item , const Vector2i & p_quadrant_pos , const CellData & r_cell_data ) ;
# endif // DEBUG_ENABLED
2021-10-21 14:42:06 +00:00
2023-06-16 12:16:37 +00:00
// Terrains.
TileSet : : TerrainsPattern _get_best_terrain_pattern_for_constraints ( int p_terrain_set , const Vector2i & p_position , const RBSet < TerrainConstraint > & p_constraints , TileSet : : TerrainsPattern p_current_pattern ) ;
RBSet < TerrainConstraint > _get_terrain_constraints_from_added_pattern ( const Vector2i & p_position , int p_terrain_set , TileSet : : TerrainsPattern p_terrains_pattern ) const ;
RBSet < TerrainConstraint > _get_terrain_constraints_from_painted_cells_list ( const RBSet < Vector2i > & p_painted , int p_terrain_set , bool p_ignore_empty_terrains ) const ;
2022-02-23 16:25:50 +00:00
2023-06-16 12:16:37 +00:00
public :
// TileMap node.
void set_tile_map ( TileMap * p_tile_map ) ;
void set_layer_index_in_tile_map_node ( int p_index ) ;
2022-02-23 16:25:50 +00:00
2023-06-16 12:16:37 +00:00
// Rect caching.
Rect2 get_rect ( bool & r_changed ) const ;
2021-10-21 14:42:06 +00:00
2023-06-16 12:16:37 +00:00
// Terrains.
HashMap < Vector2i , TileSet : : TerrainsPattern > terrain_fill_constraints ( const Vector < Vector2i > & p_to_replace , int p_terrain_set , const RBSet < TerrainConstraint > & p_constraints ) ; // Not exposed.
HashMap < Vector2i , TileSet : : TerrainsPattern > terrain_fill_connect ( const Vector < Vector2i > & p_coords_array , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ; // Not exposed.
HashMap < Vector2i , TileSet : : TerrainsPattern > terrain_fill_path ( const Vector < Vector2i > & p_coords_array , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ; // Not exposed.
HashMap < Vector2i , TileSet : : TerrainsPattern > terrain_fill_pattern ( const Vector < Vector2i > & p_coords_array , int p_terrain_set , TileSet : : TerrainsPattern p_terrains_pattern , bool p_ignore_empty_terrains = true ) ; // Not exposed.
// Not exposed to users.
TileMapCell get_cell ( const Vector2i & p_coords , bool p_use_proxies = false ) const ;
int get_effective_quadrant_size ( ) const ;
// For TileMap node's use.
void set_tile_data ( DataFormat p_format , const Vector < int > & p_data ) ;
Vector < int > get_tile_data ( ) const ;
2023-08-24 11:31:14 +00:00
void notify_tile_map_change ( DirtyFlags p_what ) ;
void internal_update ( ) ;
2023-06-16 12:16:37 +00:00
// --- Exposed in TileMap ---
// Cells manipulation.
void set_cell ( const Vector2i & p_coords , int p_source_id = TileSet : : INVALID_SOURCE , const Vector2i p_atlas_coords = TileSetSource : : INVALID_ATLAS_COORDS , int p_alternative_tile = 0 ) ;
void erase_cell ( const Vector2i & p_coords ) ;
int get_cell_source_id ( const Vector2i & p_coords , bool p_use_proxies = false ) const ;
Vector2i get_cell_atlas_coords ( const Vector2i & p_coords , bool p_use_proxies = false ) const ;
int get_cell_alternative_tile ( const Vector2i & p_coords , bool p_use_proxies = false ) const ;
TileData * get_cell_tile_data ( const Vector2i & p_coords , bool p_use_proxies = false ) const ; // Helper method to make accessing the data easier.
void clear ( ) ;
// Patterns.
Ref < TileMapPattern > get_pattern ( TypedArray < Vector2i > p_coords_array ) ;
void set_pattern ( const Vector2i & p_position , const Ref < TileMapPattern > p_pattern ) ;
// Terrains.
void set_cells_terrain_connect ( TypedArray < Vector2i > p_cells , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
void set_cells_terrain_path ( TypedArray < Vector2i > p_path , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
// Cells usage.
TypedArray < Vector2i > get_used_cells ( ) const ;
TypedArray < Vector2i > get_used_cells_by_id ( int p_source_id = TileSet : : INVALID_SOURCE , const Vector2i p_atlas_coords = TileSetSource : : INVALID_ATLAS_COORDS , int p_alternative_tile = TileSetSource : : INVALID_TILE_ALTERNATIVE ) const ;
Rect2i get_used_rect ( ) const ;
// Layer properties.
void set_name ( String p_name ) ;
String get_name ( ) const ;
void set_enabled ( bool p_enabled ) ;
bool is_enabled ( ) const ;
void set_modulate ( Color p_modulate ) ;
Color get_modulate ( ) const ;
void set_y_sort_enabled ( bool p_y_sort_enabled ) ;
bool is_y_sort_enabled ( ) const ;
void set_y_sort_origin ( int p_y_sort_origin ) ;
int get_y_sort_origin ( ) const ;
void set_z_index ( int p_z_index ) ;
int get_z_index ( ) const ;
void set_navigation_map ( RID p_map ) ;
RID get_navigation_map ( ) const ;
// Fixing and clearing methods.
void fix_invalid_tiles ( ) ;
// Find coords for body.
bool has_body_rid ( RID p_physics_body ) const ;
Vector2i get_coords_for_body_rid ( RID p_physics_body ) const ; // For finding tiles from collision.
2023-08-24 11:31:14 +00:00
~ TileMapLayer ( ) ;
2023-06-16 12:16:37 +00:00
} ;
class TileMap : public Node2D {
GDCLASS ( TileMap , Node2D ) ;
public :
2021-05-24 10:33:22 +00:00
enum VisibilityMode {
VISIBILITY_MODE_DEFAULT ,
VISIBILITY_MODE_FORCE_SHOW ,
VISIBILITY_MODE_FORCE_HIDE ,
} ;
2021-05-07 13:41:39 +00:00
private :
friend class TileSetPlugin ;
2014-02-10 01:10:30 +00:00
2021-05-24 10:33:22 +00:00
// A compatibility enum to specify how is the data if formatted.
2023-06-16 12:16:37 +00:00
mutable TileMapLayer : : DataFormat format = TileMapLayer : : FORMAT_3 ;
2014-02-10 01:10:30 +00:00
2021-07-28 16:10:01 +00:00
static constexpr float FP_ADJUST = 0.00001 ;
2021-05-24 10:33:22 +00:00
// Properties.
2021-05-07 13:41:39 +00:00
Ref < TileSet > tile_set ;
2023-08-24 11:31:14 +00:00
int rendering_quadrant_size = 16 ;
2021-09-15 13:23:58 +00:00
bool collision_animatable = false ;
2021-07-28 16:10:01 +00:00
VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT ;
VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT ;
2014-02-10 01:10:30 +00:00
2023-06-16 12:16:37 +00:00
// Layers.
LocalVector < Ref < TileMapLayer > > layers ;
2021-07-28 16:10:01 +00:00
int selected_layer = - 1 ;
2023-06-16 12:16:37 +00:00
bool pending_update = false ;
2021-07-28 16:10:01 +00:00
2021-09-15 13:23:58 +00:00
Transform2D last_valid_transform ;
Transform2D new_transform ;
2021-10-22 14:32:06 +00:00
2021-05-07 13:41:39 +00:00
void _tile_set_changed ( ) ;
2014-10-03 03:10:51 +00:00
2014-02-10 01:10:30 +00:00
protected :
2017-10-22 01:42:23 +00:00
bool _set ( const StringName & p_name , const Variant & p_value ) ;
bool _get ( const StringName & p_name , Variant & r_ret ) const ;
void _get_property_list ( List < PropertyInfo > * p_list ) const ;
2014-02-10 01:10:30 +00:00
void _notification ( int p_what ) ;
static void _bind_methods ( ) ;
2023-06-16 12:16:37 +00:00
# ifndef DISABLE_DEPRECATED
Rect2i _get_used_rect_bind_compat_78328 ( ) ;
2023-08-24 11:31:14 +00:00
void _set_quadrant_size_compat_81070 ( int p_quadrant_size ) ;
int _get_quadrant_size_compat_81070 ( ) const ;
2023-06-16 12:16:37 +00:00
static void _bind_compatibility_methods ( ) ;
# endif
2014-02-10 01:10:30 +00:00
public :
2022-12-12 10:33:42 +00:00
static Vector2i transform_coords_layout ( const Vector2i & p_coords , TileSet : : TileOffsetAxis p_offset_axis , TileSet : : TileLayout p_from_layout , TileSet : : TileLayout p_to_layout ) ;
2021-05-07 13:41:39 +00:00
2019-10-21 21:37:07 +00:00
# ifdef TOOLS_ENABLED
2020-07-10 10:34:39 +00:00
virtual Rect2 _edit_get_rect ( ) const override ;
2019-10-21 21:37:07 +00:00
# endif
2018-07-29 21:09:59 +00:00
2023-08-24 11:31:14 +00:00
# ifndef DISABLE_DEPRECATED
void force_update ( int p_layer ) ;
# endif
2023-06-16 12:16:37 +00:00
// Called by TileMapLayers.
2023-08-24 11:31:14 +00:00
void queue_internal_update ( ) ;
void _internal_update ( ) ;
2023-06-16 12:16:37 +00:00
2014-02-10 01:10:30 +00:00
void set_tileset ( const Ref < TileSet > & p_tileset ) ;
Ref < TileSet > get_tileset ( ) const ;
2023-08-24 11:31:14 +00:00
void set_rendering_quadrant_size ( int p_size ) ;
int get_rendering_quadrant_size ( ) const ;
2014-02-10 01:10:30 +00:00
2023-05-20 02:26:27 +00:00
static void draw_tile ( RID p_canvas_item , const Vector2 & p_position , const Ref < TileSet > p_tile_set , int p_atlas_source_id , const Vector2i & p_atlas_coords , int p_alternative_tile , int p_frame = - 1 , Color p_modulation = Color ( 1.0 , 1.0 , 1.0 , 1.0 ) , const TileData * p_tile_data_override = nullptr , real_t p_animation_offset = 0.0 ) ;
2021-07-28 16:10:01 +00:00
// Layers management.
int get_layers_count ( ) const ;
2021-08-31 08:48:45 +00:00
void add_layer ( int p_to_pos ) ;
void move_layer ( int p_layer , int p_to_pos ) ;
void remove_layer ( int p_layer ) ;
2023-06-16 12:16:37 +00:00
2021-07-28 16:10:01 +00:00
void set_layer_name ( int p_layer , String p_name ) ;
String get_layer_name ( int p_layer ) const ;
void set_layer_enabled ( int p_layer , bool p_visible ) ;
bool is_layer_enabled ( int p_layer ) const ;
2021-10-10 15:04:25 +00:00
void set_layer_modulate ( int p_layer , Color p_modulate ) ;
Color get_layer_modulate ( int p_layer ) const ;
2021-07-28 16:10:01 +00:00
void set_layer_y_sort_enabled ( int p_layer , bool p_enabled ) ;
bool is_layer_y_sort_enabled ( int p_layer ) const ;
void set_layer_y_sort_origin ( int p_layer , int p_y_sort_origin ) ;
int get_layer_y_sort_origin ( int p_layer ) const ;
void set_layer_z_index ( int p_layer , int p_z_index ) ;
int get_layer_z_index ( int p_layer ) const ;
2023-08-24 11:31:14 +00:00
2023-06-16 12:16:37 +00:00
void set_layer_navigation_map ( int p_layer , RID p_map ) ;
RID get_layer_navigation_map ( int p_layer ) const ;
2021-07-28 16:10:01 +00:00
void set_selected_layer ( int p_layer_id ) ; // For editor use.
int get_selected_layer ( ) const ;
2021-09-15 13:23:58 +00:00
void set_collision_animatable ( bool p_enabled ) ;
bool is_collision_animatable ( ) const ;
2021-10-21 14:42:06 +00:00
// Debug visibility modes.
2021-05-24 10:33:22 +00:00
void set_collision_visibility_mode ( VisibilityMode p_show_collision ) ;
VisibilityMode get_collision_visibility_mode ( ) ;
void set_navigation_visibility_mode ( VisibilityMode p_show_navigation ) ;
VisibilityMode get_navigation_visibility_mode ( ) ;
2021-10-21 14:42:06 +00:00
// Cells accessors.
2023-01-18 12:35:58 +00:00
void set_cell ( int p_layer , const Vector2i & p_coords , int p_source_id = TileSet : : INVALID_SOURCE , const Vector2i p_atlas_coords = TileSetSource : : INVALID_ATLAS_COORDS , int p_alternative_tile = 0 ) ;
2022-03-01 18:25:18 +00:00
void erase_cell ( int p_layer , const Vector2i & p_coords ) ;
2021-07-28 16:10:01 +00:00
int get_cell_source_id ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
Vector2i get_cell_atlas_coords ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
int get_cell_alternative_tile ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
2021-11-03 13:58:12 +00:00
// Helper method to make accessing the data easier.
TileData * get_cell_tile_data ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
2014-02-10 01:10:30 +00:00
2021-10-21 14:42:06 +00:00
// Patterns.
2021-09-29 15:48:27 +00:00
Ref < TileMapPattern > get_pattern ( int p_layer , TypedArray < Vector2i > p_coords_array ) ;
2022-12-12 10:33:42 +00:00
Vector2i map_pattern ( const Vector2i & p_position_in_tilemap , const Vector2i & p_coords_in_pattern , Ref < TileMapPattern > p_pattern ) ;
void set_pattern ( int p_layer , const Vector2i & p_position , const Ref < TileMapPattern > p_pattern ) ;
2015-08-02 15:29:37 +00:00
2023-06-16 12:16:37 +00:00
// Terrains (Not exposed).
HashMap < Vector2i , TileSet : : TerrainsPattern > 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 > terrain_fill_connect ( int p_layer , const Vector < Vector2i > & p_coords_array , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
HashMap < Vector2i , TileSet : : TerrainsPattern > terrain_fill_path ( int p_layer , const Vector < Vector2i > & p_coords_array , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
HashMap < Vector2i , TileSet : : TerrainsPattern > 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 = true ) ;
2022-02-23 16:25:50 +00:00
2023-06-16 12:16:37 +00:00
// Terrains (exposed).
2022-02-23 16:25:50 +00:00
void set_cells_terrain_connect ( int p_layer , TypedArray < Vector2i > p_cells , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
void set_cells_terrain_path ( int p_layer , TypedArray < Vector2i > p_path , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains = true ) ;
2021-10-21 14:42:06 +00:00
2023-06-16 12:16:37 +00:00
// Not exposed to users.
2021-07-28 16:10:01 +00:00
TileMapCell get_cell ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
int get_effective_quadrant_size ( int p_layer ) const ;
2017-10-22 01:42:23 +00:00
2020-09-23 19:49:50 +00:00
virtual void set_y_sort_enabled ( bool p_enable ) override ;
2018-07-22 13:26:14 +00:00
2022-08-20 16:39:05 +00:00
Vector2 map_to_local ( const Vector2i & p_pos ) const ;
Vector2i local_to_map ( const Vector2 & p_pos ) const ;
2014-10-03 03:10:51 +00:00
2021-05-07 13:41:39 +00:00
bool is_existing_neighbor ( TileSet : : CellNeighbor p_cell_neighbor ) const ;
Vector2i get_neighbor_cell ( const Vector2i & p_coords , TileSet : : CellNeighbor p_cell_neighbor ) const ;
2019-07-01 20:43:52 +00:00
2021-07-28 16:10:01 +00:00
TypedArray < Vector2i > get_used_cells ( int p_layer ) const ;
2023-01-18 12:35:58 +00:00
TypedArray < Vector2i > get_used_cells_by_id ( int p_layer , int p_source_id = TileSet : : INVALID_SOURCE , const Vector2i p_atlas_coords = TileSetSource : : INVALID_ATLAS_COORDS , int p_alternative_tile = TileSetSource : : INVALID_TILE_ALTERNATIVE ) const ;
2023-06-16 12:16:37 +00:00
Rect2i get_used_rect ( ) const ;
2017-02-20 21:02:03 +00:00
2023-06-16 12:16:37 +00:00
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems.
2020-07-10 10:34:39 +00:00
virtual void set_light_mask ( int p_light_mask ) override ;
virtual void set_material ( const Ref < Material > & p_material ) override ;
virtual void set_use_parent_material ( bool p_use_parent_material ) override ;
2020-02-19 21:26:24 +00:00
virtual void set_texture_filter ( CanvasItem : : TextureFilter p_texture_filter ) override ;
virtual void set_texture_repeat ( CanvasItem : : TextureRepeat p_texture_repeat ) override ;
2021-09-15 13:23:58 +00:00
// For finding tiles from collision.
Vector2i get_coords_for_body_rid ( RID p_physics_body ) ;
2023-04-19 04:22:46 +00:00
// For getting their layers as well.
int get_layer_for_body_rid ( RID p_physics_body ) ;
2021-09-15 13:23:58 +00:00
2022-02-23 16:25:50 +00:00
// Fixing and clearing methods.
2018-02-24 05:56:48 +00:00
void fix_invalid_tiles ( ) ;
2021-07-28 16:10:01 +00:00
2023-06-16 12:16:37 +00:00
// Clears tiles from a given layer.
2021-07-28 16:10:01 +00:00
void clear_layer ( int p_layer ) ;
2014-02-10 01:10:30 +00:00
void clear ( ) ;
2023-06-16 12:16:37 +00:00
// Force a TileMap update.
2023-08-24 11:31:14 +00:00
void update_internals ( ) ;
void notify_runtime_tile_data_update ( int p_layer = - 1 ) ;
2021-10-22 14:32:06 +00:00
// Helpers?
2022-12-12 10:33:42 +00:00
TypedArray < Vector2i > get_surrounding_cells ( const Vector2i & coords ) ;
void draw_cells_outline ( Control * p_control , const RBSet < Vector2i > & p_cells , Color p_color , Transform2D p_transform = Transform2D ( ) ) ;
2021-05-07 13:41:39 +00:00
2023-06-16 12:16:37 +00:00
// Virtual function to modify the TileData at runtime.
2021-10-22 14:32:06 +00:00
GDVIRTUAL2R ( bool , _use_tile_data_runtime_update , int , Vector2i ) ;
GDVIRTUAL3 ( _tile_data_runtime_update , int , Vector2i , TileData * ) ;
2021-07-28 16:10:01 +00:00
// Configuration warnings.
2022-09-19 15:43:15 +00:00
PackedStringArray get_configuration_warnings ( ) const override ;
2021-07-28 16:10:01 +00:00
2014-02-10 01:10:30 +00:00
TileMap ( ) ;
~ TileMap ( ) ;
} ;
2021-05-24 10:33:22 +00:00
VARIANT_ENUM_CAST ( TileMap : : VisibilityMode ) ;
2014-02-10 01:10:30 +00:00
# endif // TILE_MAP_H