2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* tile_map.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 20:16:55 +08:00
/* https://godotengine.org */
2014-02-10 09:10:30 +08:00
/*************************************************************************/
2022-01-04 04:27:34 +08:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
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. */
/*************************************************************************/
2018-01-05 07:50:27 +08:00
2014-02-10 09:10:30 +08:00
# ifndef TILE_MAP_H
# define TILE_MAP_H
2017-03-05 23:44:50 +08:00
# include "scene/2d/node_2d.h"
2021-05-07 21:41:39 +08:00
# include "scene/gui/control.h"
2014-02-10 09:10:30 +08:00
# include "scene/resources/tile_set.h"
2021-05-07 21:41:39 +08:00
class TileSetAtlasSource ;
2019-02-06 07:45:40 +08:00
2021-05-07 21:41:39 +08:00
struct TileMapQuadrant {
struct CoordsWorldComparator {
_ALWAYS_INLINE_ bool operator ( ) ( const Vector2i & p_a , const Vector2i & p_b ) const {
// We sort the cells by their world 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 ;
}
}
2017-10-22 09:42:23 +08:00
} ;
2021-05-07 21:41:39 +08:00
// Dirty list element
SelfList < TileMapQuadrant > dirty_list_element ;
2021-07-29 00:10:01 +08:00
// Quadrant layer and coords.
int layer = - 1 ;
2021-05-07 21:41:39 +08:00
Vector2i coords ;
// TileMapCells
Set < Vector2i > cells ;
// We need those two maps to sort by world position for rendering
// This is kind of workaround, it would be better to sort the cells directly in the "cells" set instead.
Map < Vector2i , Vector2i > map_to_world ;
Map < Vector2i , Vector2i , CoordsWorldComparator > world_to_map ;
// Debug.
RID debug_canvas_item ;
2021-05-18 21:40:52 +08:00
// Rendering.
2021-05-07 21:41:39 +08:00
List < RID > canvas_items ;
List < RID > occluders ;
// Physics.
List < RID > bodies ;
2021-05-18 21:40:52 +08:00
// Navigation.
2021-05-07 21:41:39 +08:00
Map < Vector2i , Vector < RID > > navigation_regions ;
2021-05-18 21:40:52 +08:00
// Scenes.
Map < Vector2i , String > scenes ;
2021-10-22 22:32:06 +08:00
// Runtime TileData cache.
Map < Vector2i , TileData * > runtime_tile_data_cache ;
2021-05-07 21:41:39 +08:00
void operator = ( const TileMapQuadrant & q ) {
2021-07-29 00:10:01 +08:00
layer = q . layer ;
2021-05-07 21:41:39 +08:00
coords = q . coords ;
debug_canvas_item = q . debug_canvas_item ;
canvas_items = q . canvas_items ;
occluders = q . occluders ;
bodies = q . bodies ;
navigation_regions = q . navigation_regions ;
}
TileMapQuadrant ( const TileMapQuadrant & q ) :
dirty_list_element ( this ) {
2021-07-29 00:10:01 +08:00
layer = q . layer ;
2021-05-07 21:41:39 +08:00
coords = q . coords ;
debug_canvas_item = q . debug_canvas_item ;
canvas_items = q . canvas_items ;
occluders = q . occluders ;
bodies = q . bodies ;
navigation_regions = q . navigation_regions ;
}
TileMapQuadrant ( ) :
dirty_list_element ( this ) {
}
} ;
2019-07-08 17:35:52 +08:00
2021-05-07 21:41:39 +08:00
class TileMap : public Node2D {
GDCLASS ( TileMap , Node2D ) ;
2015-03-09 13:34:56 +08:00
2021-05-07 21:41:39 +08:00
public :
2021-10-21 22:42:06 +08:00
class TerrainConstraint {
private :
const TileMap * tile_map ;
Vector2i base_cell_coords = Vector2i ( ) ;
int bit = - 1 ;
int terrain = - 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} " , base_cell_coords , bit , terrain ) ;
}
Vector2i get_base_cell_coords ( ) const {
return base_cell_coords ;
}
Map < 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 ;
}
TerrainConstraint ( const TileMap * p_tile_map , const Vector2i & p_position , const TileSet : : CellNeighbor & p_bit , int p_terrain ) ;
TerrainConstraint ( ) { }
} ;
2021-05-24 18:33:22 +08:00
enum VisibilityMode {
VISIBILITY_MODE_DEFAULT ,
VISIBILITY_MODE_FORCE_SHOW ,
VISIBILITY_MODE_FORCE_HIDE ,
} ;
2021-05-07 21:41:39 +08:00
private :
friend class TileSetPlugin ;
2014-02-10 09:10:30 +08:00
2021-05-24 18:33:22 +08:00
// A compatibility enum to specify how is the data if formatted.
2021-05-07 21:41:39 +08:00
enum DataFormat {
FORMAT_1 = 0 ,
FORMAT_2 ,
FORMAT_3
2014-02-10 09:10:30 +08:00
} ;
2021-05-24 18:33:22 +08:00
mutable DataFormat format = FORMAT_1 ; // Assume lowest possible format if none is present;
2014-02-10 09:10:30 +08:00
2021-07-29 00:10:01 +08:00
static constexpr float FP_ADJUST = 0.00001 ;
2021-05-24 18:33:22 +08:00
// Properties.
2021-05-07 21:41:39 +08:00
Ref < TileSet > tile_set ;
2021-05-24 18:33:22 +08:00
int quadrant_size = 16 ;
2021-09-15 21:23:58 +08:00
bool collision_animatable = false ;
2021-07-29 00:10:01 +08:00
VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT ;
VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT ;
2014-02-10 09:10:30 +08:00
2021-05-24 18:33:22 +08:00
// Updates.
2021-02-08 05:29:31 +08:00
bool pending_update = false ;
2014-02-10 09:10:30 +08:00
2021-05-24 18:33:22 +08:00
// Rect.
2014-02-10 09:10:30 +08:00
Rect2 rect_cache ;
2021-02-08 05:29:31 +08:00
bool rect_cache_dirty = true ;
2021-08-06 00:17:36 +08:00
Rect2i used_rect_cache ;
bool used_rect_cache_dirty = true ;
2021-05-07 21:41:39 +08:00
2021-07-29 00:10:01 +08:00
// TileMap layers.
struct TileMapLayer {
String name ;
bool enabled = true ;
2021-10-10 23:04:25 +08:00
Color modulate = Color ( 1 , 1 , 1 , 1 ) ;
2021-07-29 00:10:01 +08:00
bool y_sort_enabled = false ;
int y_sort_origin = 0 ;
int z_index = 0 ;
RID canvas_item ;
Map < Vector2i , TileMapCell > tile_map ;
Map < Vector2i , TileMapQuadrant > quadrant_map ;
SelfList < TileMapQuadrant > : : List dirty_quadrant_list ;
} ;
LocalVector < TileMapLayer > layers ;
int selected_layer = - 1 ;
2021-09-15 21:23:58 +08:00
// Mapping for RID to coords.
Map < RID , Vector2i > bodies_coords ;
2021-07-29 00:10:01 +08:00
// Quadrants and internals management.
Vector2i _coords_to_quadrant_coords ( int p_layer , const Vector2i & p_coords ) const ;
Map < Vector2i , TileMapQuadrant > : : Element * _create_quadrant ( int p_layer , const Vector2i & p_qk ) ;
void _make_quadrant_dirty ( Map < Vector2i , TileMapQuadrant > : : Element * Q ) ;
void _make_all_quadrants_dirty ( ) ;
void _queue_update_dirty_quadrants ( ) ;
void _update_dirty_quadrants ( ) ;
2021-05-24 18:33:22 +08:00
2021-10-27 17:53:29 +08:00
void _recreate_layer_internals ( int p_layer ) ;
2021-07-29 00:10:01 +08:00
void _recreate_internals ( ) ;
2021-05-07 21:41:39 +08:00
void _erase_quadrant ( Map < Vector2i , TileMapQuadrant > : : Element * Q ) ;
2021-07-29 00:10:01 +08:00
void _clear_layer_internals ( int p_layer ) ;
void _clear_internals ( ) ;
// Rect caching.
2014-02-10 09:10:30 +08:00
void _recompute_rect_cache ( ) ;
2021-07-29 00:10:01 +08:00
// Per-system methods.
bool _rendering_quadrant_order_dirty = false ;
void _rendering_notification ( int p_what ) ;
void _rendering_update_layer ( int p_layer ) ;
void _rendering_cleanup_layer ( int p_layer ) ;
void _rendering_update_dirty_quadrants ( SelfList < TileMapQuadrant > : : List & r_dirty_quadrant_list ) ;
void _rendering_create_quadrant ( TileMapQuadrant * p_quadrant ) ;
void _rendering_cleanup_quadrant ( TileMapQuadrant * p_quadrant ) ;
void _rendering_draw_quadrant_debug ( TileMapQuadrant * p_quadrant ) ;
2021-09-15 21:23:58 +08:00
Transform2D last_valid_transform ;
Transform2D new_transform ;
2021-07-29 00:10:01 +08:00
void _physics_notification ( int p_what ) ;
void _physics_update_dirty_quadrants ( SelfList < TileMapQuadrant > : : List & r_dirty_quadrant_list ) ;
void _physics_cleanup_quadrant ( TileMapQuadrant * p_quadrant ) ;
void _physics_draw_quadrant_debug ( TileMapQuadrant * p_quadrant ) ;
void _navigation_notification ( int p_what ) ;
void _navigation_update_dirty_quadrants ( SelfList < TileMapQuadrant > : : List & r_dirty_quadrant_list ) ;
void _navigation_cleanup_quadrant ( TileMapQuadrant * p_quadrant ) ;
void _navigation_draw_quadrant_debug ( TileMapQuadrant * p_quadrant ) ;
void _scenes_update_dirty_quadrants ( SelfList < TileMapQuadrant > : : List & r_dirty_quadrant_list ) ;
void _scenes_cleanup_quadrant ( TileMapQuadrant * p_quadrant ) ;
void _scenes_draw_quadrant_debug ( TileMapQuadrant * p_quadrant ) ;
2021-10-21 22:42:06 +08:00
// Terrains.
Set < TileSet : : TerrainsPattern > _get_valid_terrains_patterns_for_constraints ( int p_terrain_set , const Vector2i & p_position , Set < TerrainConstraint > p_constraints ) ;
2021-05-24 18:33:22 +08:00
// Set and get tiles from data arrays.
2021-07-29 00:10:01 +08:00
void _set_tile_data ( int p_layer , const Vector < int > & p_data ) ;
Vector < int > _get_tile_data ( int p_layer ) const ;
2014-10-03 11:10:51 +08:00
2021-10-22 22:32:06 +08:00
void _build_runtime_update_tile_data ( SelfList < TileMapQuadrant > : : List & r_dirty_quadrant_list ) ;
2021-05-07 21:41:39 +08:00
void _tile_set_changed ( ) ;
2021-10-13 20:49:28 +08:00
bool _tile_set_changed_deferred_update_needed = false ;
void _tile_set_changed_deferred_update ( ) ;
2014-10-03 11:10:51 +08:00
2014-02-10 09:10:30 +08:00
protected :
2017-10-22 09:42:23 +08: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 09:10:30 +08:00
void _notification ( int p_what ) ;
static void _bind_methods ( ) ;
public :
2021-05-07 21:41:39 +08:00
static Vector2i transform_coords_layout ( Vector2i p_coords , TileSet : : TileOffsetAxis p_offset_axis , TileSet : : TileLayout p_from_layout , TileSet : : TileLayout p_to_layout ) ;
2014-02-10 09:10:30 +08:00
enum {
2017-03-05 23:44:50 +08:00
INVALID_CELL = - 1
2014-02-10 09:10:30 +08:00
} ;
2019-10-22 05:37:07 +08:00
# ifdef TOOLS_ENABLED
2020-07-10 18:34:39 +08:00
virtual Rect2 _edit_get_rect ( ) const override ;
2019-10-22 05:37:07 +08:00
# endif
2018-07-30 05:09:59 +08:00
2017-03-05 23:44:50 +08:00
void set_tileset ( const Ref < TileSet > & p_tileset ) ;
2014-02-10 09:10:30 +08:00
Ref < TileSet > get_tileset ( ) const ;
void set_quadrant_size ( int p_size ) ;
int get_quadrant_size ( ) const ;
2021-10-22 22:32:06 +08:00
static void draw_tile ( RID p_canvas_item , Vector2i p_position , const Ref < TileSet > p_tile_set , int p_atlas_source_id , 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 ) ;
2021-07-29 00:10:01 +08:00
// Layers management.
int get_layers_count ( ) const ;
2021-08-31 16:48:45 +08:00
void add_layer ( int p_to_pos ) ;
void move_layer ( int p_layer , int p_to_pos ) ;
void remove_layer ( int p_layer ) ;
2021-07-29 00:10:01 +08: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 23:04:25 +08:00
void set_layer_modulate ( int p_layer , Color p_modulate ) ;
Color get_layer_modulate ( int p_layer ) const ;
2021-07-29 00:10:01 +08: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 ;
void set_selected_layer ( int p_layer_id ) ; // For editor use.
int get_selected_layer ( ) const ;
2021-09-15 21:23:58 +08:00
void set_collision_animatable ( bool p_enabled ) ;
bool is_collision_animatable ( ) const ;
2021-10-21 22:42:06 +08:00
// Debug visibility modes.
2021-05-24 18:33:22 +08: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 22:42:06 +08:00
// Cells accessors.
2022-03-02 02:25:18 +08:00
void set_cell ( int p_layer , const Vector2i & p_coords , int p_source_id = - 1 , const Vector2i p_atlas_coords = TileSetSource : : INVALID_ATLAS_COORDS , int p_alternative_tile = 0 ) ;
void erase_cell ( int p_layer , const Vector2i & p_coords ) ;
2021-07-29 00:10:01 +08: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 ;
2014-02-10 09:10:30 +08:00
2021-10-21 22:42:06 +08:00
// Patterns.
2021-09-29 23:48:27 +08:00
Ref < TileMapPattern > get_pattern ( int p_layer , TypedArray < Vector2i > p_coords_array ) ;
Vector2i map_pattern ( Vector2i p_position_in_tilemap , Vector2i p_coords_in_pattern , Ref < TileMapPattern > p_pattern ) ;
void set_pattern ( int p_layer , Vector2i p_position , const Ref < TileMapPattern > p_pattern ) ;
2015-08-02 23:29:37 +08:00
2021-10-21 22:42:06 +08:00
// Terrains.
Set < TerrainConstraint > get_terrain_constraints_from_removed_cells_list ( int p_layer , const Set < Vector2i > & p_to_replace , int p_terrain_set , bool p_ignore_empty_terrains = true ) const ; // Not exposed.
Set < TerrainConstraint > get_terrain_constraints_from_added_tile ( Vector2i p_position , int p_terrain_set , TileSet : : TerrainsPattern p_terrains_pattern ) const ; // Not exposed.
Map < Vector2i , TileSet : : TerrainsPattern > terrain_wave_function_collapse ( const Set < Vector2i > & p_to_replace , int p_terrain_set , const Set < TerrainConstraint > p_constraints ) ; // Not exposed.
void set_cells_from_surrounding_terrains ( int p_layer , TypedArray < Vector2i > p_coords_array , int p_terrain_set , bool p_ignore_empty_terrains = true ) ;
2021-05-07 21:41:39 +08:00
// Not exposed to users
2021-07-29 00:10:01 +08:00
TileMapCell get_cell ( int p_layer , const Vector2i & p_coords , bool p_use_proxies = false ) const ;
Map < Vector2i , TileMapQuadrant > * get_quadrant_map ( int p_layer ) ;
int get_effective_quadrant_size ( int p_layer ) const ;
//---
2017-10-22 09:42:23 +08:00
2020-09-24 03:49:50 +08:00
virtual void set_y_sort_enabled ( bool p_enable ) override ;
2018-07-22 21:26:14 +08:00
2020-06-30 14:34:15 +08:00
Vector2 map_to_world ( const Vector2i & p_pos ) const ;
2021-05-07 21:41:39 +08:00
Vector2i world_to_map ( const Vector2 & p_pos ) const ;
2014-10-03 11:10:51 +08:00
2021-05-07 21:41:39 +08: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-02 04:43:52 +08:00
2021-07-29 00:10:01 +08:00
TypedArray < Vector2i > get_used_cells ( int p_layer ) const ;
2017-02-21 05:02:03 +08:00
Rect2 get_used_rect ( ) ; // Not const because of cache
2021-05-07 21:41:39 +08:00
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems
2020-07-10 18:34:39 +08: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-20 05:26:24 +08: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 21:23:58 +08:00
// For finding tiles from collision.
Vector2i get_coords_for_body_rid ( RID p_physics_body ) ;
2021-07-29 00:10:01 +08:00
// Fixing a nclearing methods.
2018-02-24 13:56:48 +08:00
void fix_invalid_tiles ( ) ;
2021-07-29 00:10:01 +08:00
2021-10-22 22:32:06 +08:00
// Clears tiles from a given layer
2021-07-29 00:10:01 +08:00
void clear_layer ( int p_layer ) ;
2014-02-10 09:10:30 +08:00
void clear ( ) ;
2021-10-22 22:32:06 +08:00
// Force a TileMap update
void force_update ( int p_layer = - 1 ) ;
// Helpers?
2021-05-07 21:41:39 +08:00
TypedArray < Vector2i > get_surrounding_tiles ( Vector2i coords ) ;
void draw_cells_outline ( Control * p_control , Set < Vector2i > p_cells , Color p_color , Transform2D p_transform = Transform2D ( ) ) ;
2021-10-22 22:32:06 +08:00
// Virtual function to modify the TileData at runtime
GDVIRTUAL2R ( bool , _use_tile_data_runtime_update , int , Vector2i ) ;
GDVIRTUAL3 ( _tile_data_runtime_update , int , Vector2i , TileData * ) ;
2021-07-29 00:10:01 +08:00
// Configuration warnings.
TypedArray < String > get_configuration_warnings ( ) const override ;
2014-02-10 09:10:30 +08:00
TileMap ( ) ;
~ TileMap ( ) ;
} ;
2021-05-24 18:33:22 +08:00
VARIANT_ENUM_CAST ( TileMap : : VisibilityMode ) ;
2014-02-10 09:10:30 +08:00
# endif // TILE_MAP_H