2024-03-01 11:56:19 +01:00
/*************************************************************************/
/* layered_tile_map.cpp */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM ENGINE */
/* https://github.com/Relintai/pandemonium_engine */
/*************************************************************************/
/* Copyright (c) 2022-present Péter Magyar. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* Copyright (c) 2007-2022 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. */
/*************************************************************************/
2024-03-01 10:38:08 +01:00
2024-03-01 16:07:31 +01:00
# include "layered_tile_map.h"
2024-03-01 10:38:08 +01:00
2024-03-03 09:39:24 +01:00
# include "core/config/engine.h"
2024-03-01 10:38:08 +01:00
# include "core/core_string_names.h"
2024-03-02 14:30:29 +01:00
# include "layered_tile_map_layer.h"
# include "scene/main/control.h"
2024-03-01 10:38:08 +01:00
# define TILEMAP_CALL_FOR_LAYER(layer, function, ...) \
if ( layer < 0 ) { \
layer = layers . size ( ) + layer ; \
} ; \
ERR_FAIL_INDEX ( layer , ( int ) layers . size ( ) ) ; \
layers [ layer ] - > function ( __VA_ARGS__ ) ;
# define TILEMAP_CALL_FOR_LAYER_V(layer, err_value, function, ...) \
if ( layer < 0 ) { \
layer = layers . size ( ) + layer ; \
} ; \
ERR_FAIL_INDEX_V ( layer , ( int ) layers . size ( ) , err_value ) ; \
return layers [ layer ] - > function ( __VA_ARGS__ ) ;
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : _emit_changed ( ) {
2024-03-01 10:38:08 +01:00
emit_signal ( CoreStringNames : : get_singleton ( ) - > changed ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : _notification ( int p_what ) {
2024-03-01 10:38:08 +01:00
switch ( p_what ) {
2024-03-01 15:36:53 +01:00
case LayeredTileMap : : NOTIFICATION_INTERNAL_PHYSICS_PROCESS : {
2024-03-01 10:38:08 +01:00
// This is only executed when collision_animatable is enabled.
bool in_editor = false ;
# ifdef TOOLS_ENABLED
in_editor = Engine : : get_singleton ( ) - > is_editor_hint ( ) ;
# endif
if ( is_inside_tree ( ) & & collision_animatable & & ! in_editor ) {
// Update transform on the physics tick when in animatable mode.
last_valid_transform = new_transform ;
set_notify_local_transform ( false ) ;
set_global_transform ( new_transform ) ;
set_notify_local_transform ( true ) ;
}
} break ;
2024-03-01 15:36:53 +01:00
case LayeredTileMap : : NOTIFICATION_LOCAL_TRANSFORM_CHANGED : {
2024-03-01 10:38:08 +01:00
// This is only executed when collision_animatable is enabled.
bool in_editor = false ;
# ifdef TOOLS_ENABLED
in_editor = Engine : : get_singleton ( ) - > is_editor_hint ( ) ;
# endif
if ( is_inside_tree ( ) & & collision_animatable & & ! in_editor ) {
// Store last valid transform.
new_transform = get_global_transform ( ) ;
// ... but then revert changes.
set_notify_local_transform ( false ) ;
set_global_transform ( last_valid_transform ) ;
set_notify_local_transform ( true ) ;
}
} break ;
}
}
# ifndef DISABLE_DEPRECATED
// Deprecated methods.
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : force_update ( int p_layer ) {
2024-03-01 10:38:08 +01:00
notify_runtime_tile_data_update ( p_layer ) ;
update_internals ( ) ;
}
# endif
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_rendering_quadrant_size ( int p_size ) {
ERR_FAIL_COND_MSG ( p_size < 1 , " LayeredTileMapQuadrant size cannot be smaller than 1. " ) ;
2024-03-01 10:38:08 +01:00
rendering_quadrant_size = p_size ;
2024-03-02 14:30:29 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > set_rendering_quadrant_size ( p_size ) ;
}
_emit_changed ( ) ;
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_rendering_quadrant_size ( ) const {
2024-03-01 10:38:08 +01:00
return rendering_quadrant_size ;
}
2024-03-02 14:30:29 +01:00
void LayeredTileMap : : draw_tile ( RID p_canvas_item , const Vector2 & p_position , const Ref < LayeredTileSet > p_tile_set , int p_atlas_source_id , const Vector2i & p_atlas_coords , int p_alternative_tile , int p_frame , Color p_modulation , const LayeredTileData * p_tile_data_override , real_t p_normalized_animation_offset ) {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND ( ! p_tile_set . is_valid ( ) ) ;
ERR_FAIL_COND ( ! p_tile_set - > has_source ( p_atlas_source_id ) ) ;
ERR_FAIL_COND ( ! p_tile_set - > get_source ( p_atlas_source_id ) - > has_tile ( p_atlas_coords ) ) ;
ERR_FAIL_COND ( ! p_tile_set - > get_source ( p_atlas_source_id ) - > has_alternative_tile ( p_atlas_coords , p_alternative_tile ) ) ;
2024-03-01 15:36:53 +01:00
LayeredTileSetSource * source = * p_tile_set - > get_source ( p_atlas_source_id ) ;
LayeredTileSetAtlasSource * atlas_source = Object : : cast_to < LayeredTileSetAtlasSource > ( source ) ;
2024-03-01 10:38:08 +01:00
if ( atlas_source ) {
// Check for the frame.
if ( p_frame > = 0 ) {
ERR_FAIL_INDEX ( p_frame , atlas_source - > get_tile_animation_frames_count ( p_atlas_coords ) ) ;
}
// Get the texture.
2024-03-02 08:11:38 +01:00
Ref < Texture > tex = atlas_source - > get_runtime_texture ( ) ;
2024-03-01 10:38:08 +01:00
if ( ! tex . is_valid ( ) ) {
return ;
}
// Check if we are in the texture, return otherwise.
Vector2i grid_size = atlas_source - > get_atlas_grid_size ( ) ;
if ( p_atlas_coords . x > = grid_size . x | | p_atlas_coords . y > = grid_size . y ) {
return ;
}
// Get tile data.
2024-03-02 14:30:29 +01:00
const LayeredTileData * tile_data = p_tile_data_override ? p_tile_data_override : atlas_source - > get_tile_data ( p_atlas_coords , p_alternative_tile ) ;
2024-03-01 10:38:08 +01:00
// Get the tile modulation.
Color modulate = tile_data - > get_modulate ( ) * p_modulation ;
// Compute the offset.
Vector2 tile_offset = tile_data - > get_texture_origin ( ) ;
// Get destination rect.
Rect2 dest_rect ;
dest_rect . size = atlas_source - > get_runtime_tile_texture_region ( p_atlas_coords ) . size ;
dest_rect . size . x + = FP_ADJUST ;
dest_rect . size . y + = FP_ADJUST ;
2024-03-01 15:36:53 +01:00
bool transpose = tile_data - > get_transpose ( ) ^ bool ( p_alternative_tile & LayeredTileSetAtlasSource : : TRANSFORM_TRANSPOSE ) ;
2024-03-01 10:38:08 +01:00
if ( transpose ) {
dest_rect . position = ( p_position - Vector2 ( dest_rect . size . y , dest_rect . size . x ) / 2 - tile_offset ) ;
} else {
dest_rect . position = ( p_position - dest_rect . size / 2 - tile_offset ) ;
}
2024-03-01 15:36:53 +01:00
if ( tile_data - > get_flip_h ( ) ^ bool ( p_alternative_tile & LayeredTileSetAtlasSource : : TRANSFORM_FLIP_H ) ) {
2024-03-01 10:38:08 +01:00
dest_rect . size . x = - dest_rect . size . x ;
}
2024-03-01 15:36:53 +01:00
if ( tile_data - > get_flip_v ( ) ^ bool ( p_alternative_tile & LayeredTileSetAtlasSource : : TRANSFORM_FLIP_V ) ) {
2024-03-01 10:38:08 +01:00
dest_rect . size . y = - dest_rect . size . y ;
}
// Draw the tile.
if ( p_frame > = 0 ) {
Rect2i source_rect = atlas_source - > get_runtime_tile_texture_region ( p_atlas_coords , p_frame ) ;
2024-03-02 14:30:29 +01:00
tex - > draw_rect_region ( p_canvas_item , dest_rect , source_rect , modulate , transpose , Ref < Texture > ( ) , p_tile_set - > is_uv_clipping ( ) ) ;
2024-03-01 10:38:08 +01:00
} else if ( atlas_source - > get_tile_animation_frames_count ( p_atlas_coords ) = = 1 ) {
Rect2i source_rect = atlas_source - > get_runtime_tile_texture_region ( p_atlas_coords , 0 ) ;
2024-03-02 14:30:29 +01:00
tex - > draw_rect_region ( p_canvas_item , dest_rect , source_rect , modulate , transpose , Ref < Texture > ( ) , p_tile_set - > is_uv_clipping ( ) ) ;
2024-03-01 10:38:08 +01:00
} else {
2024-03-02 14:56:37 +01:00
// RenderingServer::get_singleton()->canvas_item_add_animation_slice is implemented here in godot4:
// https://github.com/godotengine/godot/commit/94d31ac327a8fe6ff7c007b34cb25772bf96d17e
// RenderingServer::get_singleton()->canvas_item_add_animation_slice in godot4 is actually pretty clever
// But this implementation will be relatively easy to break due to the canvas batcher
// It would likely work with the code below, but it would be available to scripting too.
// Possible solution #1
// So I think it would make a lot more sense to do it in a different way, after the module is working.
// The api could look like:
// RenderingServer::get_singleton()->canvas_item_add_animated_sprite(RID ci, const Array &p_animation_data);
// p_animation_data:
// [i + 0]: duration
// [i + 1]: dest_rect
// [i + 2]: source_rect
// [i + 3]: modulate
// [i + 4]: transpose
// [i + 5]: normal
// [i + 6]: is_uv_clipping
// [i + 7]: Ref<Texture>
// This could create a new Command. It's internal data could be updated automatically when processing batches.
// This would make the api impossible to break in different cases.
// Also it would be simple to use for other things.
// Possible solution #2
// Handle animated tile updates here
// solution #1 is likely easier
// Possible solution #3
// Add more canvas items and show/hide them as necessary
// solution #1 is likely easier
ERR_PRINT ( " TODO Reimplement tile animations! " ) ;
/*
2024-03-01 10:38:08 +01:00
real_t speed = atlas_source - > get_tile_animation_speed ( p_atlas_coords ) ;
real_t animation_duration = atlas_source - > get_tile_animation_total_duration ( p_atlas_coords ) / speed ;
real_t animation_offset = p_normalized_animation_offset * animation_duration ;
// Accumulate durations unaffected by the speed to avoid accumulating floating point division errors.
// Aka do `sum(duration[i]) / speed` instead of `sum(duration[i] / speed)`.
real_t time_unscaled = 0.0 ;
for ( int frame = 0 ; frame < atlas_source - > get_tile_animation_frames_count ( p_atlas_coords ) ; frame + + ) {
real_t frame_duration_unscaled = atlas_source - > get_tile_animation_frame_duration ( p_atlas_coords , frame ) ;
real_t slice_start = time_unscaled / speed ;
real_t slice_end = ( time_unscaled + frame_duration_unscaled ) / speed ;
RenderingServer : : get_singleton ( ) - > canvas_item_add_animation_slice ( p_canvas_item , animation_duration , slice_start , slice_end , animation_offset ) ;
Rect2i source_rect = atlas_source - > get_runtime_tile_texture_region ( p_atlas_coords , frame ) ;
2024-03-02 14:30:29 +01:00
tex - > draw_rect_region ( p_canvas_item , dest_rect , source_rect , modulate , transpose , Ref < Texture > ( ) , p_tile_set - > is_uv_clipping ( ) ) ;
2024-03-01 10:38:08 +01:00
time_unscaled + = frame_duration_unscaled ;
}
RenderingServer : : get_singleton ( ) - > canvas_item_add_animation_slice ( p_canvas_item , 1.0 , 0.0 , 1.0 , 0.0 ) ;
2024-03-02 14:56:37 +01:00
*/
2024-03-01 10:38:08 +01:00
}
}
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_layers_count ( ) const {
2024-03-01 10:38:08 +01:00
return layers . size ( ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : add_layer ( int p_to_pos ) {
2024-03-01 10:38:08 +01:00
if ( p_to_pos < 0 ) {
p_to_pos = layers . size ( ) + p_to_pos + 1 ;
}
ERR_FAIL_INDEX ( p_to_pos , ( int ) layers . size ( ) + 1 ) ;
// Must clear before adding the layer.
2024-03-01 15:36:53 +01:00
LayeredTileMapLayer * new_layer = memnew ( LayeredTileMapLayer ) ;
2024-03-01 10:38:08 +01:00
layers . insert ( p_to_pos , new_layer ) ;
2024-03-03 09:39:24 +01:00
add_child ( new_layer , false ) ;
move_child ( new_layer , 0 ) ;
2024-03-01 10:38:08 +01:00
new_layer - > set_name ( vformat ( " Layer%d " , p_to_pos ) ) ;
move_child ( new_layer , p_to_pos ) ;
for ( uint32_t i = 0 ; i < layers . size ( ) ; i + + ) {
layers [ i ] - > set_as_tile_map_internal_node ( i ) ;
}
2024-03-03 09:39:24 +01:00
new_layer - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _emit_changed " ) ;
2024-03-01 10:38:08 +01:00
2024-03-02 09:13:07 +01:00
property_list_changed_notify ( ) ;
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
2024-03-03 09:39:24 +01:00
update_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : move_layer ( int p_layer , int p_to_pos ) {
2024-03-01 10:38:08 +01:00
ERR_FAIL_INDEX ( p_layer , ( int ) layers . size ( ) ) ;
ERR_FAIL_INDEX ( p_to_pos , ( int ) layers . size ( ) + 1 ) ;
// Clear before shuffling layers.
2024-03-01 15:36:53 +01:00
LayeredTileMapLayer * layer = layers [ p_layer ] ;
2024-03-01 10:38:08 +01:00
layers . insert ( p_to_pos , layer ) ;
2024-03-02 09:13:07 +01:00
layers . remove ( p_to_pos < p_layer ? p_layer + 1 : p_layer ) ;
2024-03-01 10:38:08 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; i + + ) {
move_child ( layers [ i ] , i ) ;
layers [ i ] - > set_as_tile_map_internal_node ( i ) ;
}
2024-03-02 09:13:07 +01:00
property_list_changed_notify ( ) ;
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
2024-03-03 09:39:24 +01:00
update_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : remove_layer ( int p_layer ) {
2024-03-01 10:38:08 +01:00
ERR_FAIL_INDEX ( p_layer , ( int ) layers . size ( ) ) ;
// Clear before removing the layer.
2024-03-03 09:39:24 +01:00
layers [ p_layer ] - > queue_delete ( ) ;
2024-03-02 09:13:07 +01:00
layers . remove ( p_layer ) ;
2024-03-01 10:38:08 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; i + + ) {
layers [ i ] - > set_as_tile_map_internal_node ( i ) ;
}
2024-03-02 09:13:07 +01:00
property_list_changed_notify ( ) ;
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
2024-03-03 09:39:24 +01:00
update_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_name ( int p_layer , String p_name ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_name , p_name ) ;
}
2024-03-01 15:36:53 +01:00
String LayeredTileMap : : get_layer_name ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , " " , get_name ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_enabled ( int p_layer , bool p_enabled ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_enabled , p_enabled ) ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : is_layer_enabled ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , false , is_enabled ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_modulate ( int p_layer , Color p_modulate ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_modulate , p_modulate ) ;
}
2024-03-01 15:36:53 +01:00
Color LayeredTileMap : : get_layer_modulate ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , Color ( ) , get_modulate ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_y_sort_enabled ( int p_layer , bool p_y_sort_enabled ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_y_sort_enabled , p_y_sort_enabled ) ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : is_layer_y_sort_enabled ( int p_layer ) const {
2024-03-03 09:39:24 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , false , is_sort_enabled ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_y_sort_origin ( int p_layer , int p_y_sort_origin ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_y_sort_origin , p_y_sort_origin ) ;
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_layer_y_sort_origin ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , 0 , get_y_sort_origin ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_z_index ( int p_layer , int p_z_index ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_z_index , p_z_index ) ;
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_layer_z_index ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , 0 , get_z_index ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_navigation_enabled ( int p_layer , bool p_enabled ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_navigation_enabled , p_enabled ) ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : is_layer_navigation_enabled ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , false , is_navigation_enabled ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_layer_navigation_map ( int p_layer , RID p_map ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_navigation_map , p_map ) ;
}
2024-03-01 15:36:53 +01:00
RID LayeredTileMap : : get_layer_navigation_map ( int p_layer ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , RID ( ) , get_navigation_map ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_collision_animatable ( bool p_collision_animatable ) {
2024-03-01 10:38:08 +01:00
if ( collision_animatable = = p_collision_animatable ) {
return ;
}
collision_animatable = p_collision_animatable ;
set_notify_local_transform ( p_collision_animatable ) ;
set_physics_process_internal ( p_collision_animatable ) ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > set_use_kinematic_bodies ( layer ) ;
}
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : is_collision_animatable ( ) const {
2024-03-01 10:38:08 +01:00
return collision_animatable ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_collision_visibility_mode ( LayeredTileMap : : VisibilityMode p_show_collision ) {
2024-03-01 10:38:08 +01:00
if ( collision_visibility_mode = = p_show_collision ) {
return ;
}
collision_visibility_mode = p_show_collision ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 15:36:53 +01:00
layer - > set_collision_visibility_mode ( LayeredTileMapLayer : : VisibilityMode ( p_show_collision ) ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-03 09:39:24 +01:00
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
}
2024-03-01 15:36:53 +01:00
LayeredTileMap : : VisibilityMode LayeredTileMap : : get_collision_visibility_mode ( ) const {
2024-03-01 10:38:08 +01:00
return collision_visibility_mode ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_navigation_visibility_mode ( LayeredTileMap : : VisibilityMode p_show_navigation ) {
2024-03-01 10:38:08 +01:00
if ( navigation_visibility_mode = = p_show_navigation ) {
return ;
}
navigation_visibility_mode = p_show_navigation ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 15:36:53 +01:00
layer - > set_navigation_visibility_mode ( LayeredTileMapLayer : : VisibilityMode ( p_show_navigation ) ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-03 09:39:24 +01:00
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
}
2024-03-01 15:36:53 +01:00
LayeredTileMap : : VisibilityMode LayeredTileMap : : get_navigation_visibility_mode ( ) const {
2024-03-01 10:38:08 +01:00
return navigation_visibility_mode ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_y_sort_enabled ( bool p_enable ) {
2024-03-03 09:39:24 +01:00
if ( is_sort_enabled ( ) = = p_enable ) {
2024-03-01 10:38:08 +01:00
return ;
}
2024-03-03 09:39:24 +01:00
YSort : : set_sort_enabled ( p_enable ) ;
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > set_y_sort_enabled ( p_enable ) ;
}
2024-03-03 09:39:24 +01:00
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
2024-03-03 09:39:24 +01:00
update_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_cell ( int p_layer , const Vector2i & p_coords , int p_source_id , const Vector2i p_atlas_coords , int p_alternative_tile ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_cell , p_coords , p_source_id , p_atlas_coords , p_alternative_tile ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : erase_cell ( int p_layer , const Vector2i & p_coords ) {
TILEMAP_CALL_FOR_LAYER ( p_layer , set_cell , p_coords , LayeredTileSet : : INVALID_SOURCE , LayeredTileSetSource : : INVALID_ATLAS_COORDS , LayeredTileSetSource : : INVALID_TILE_ALTERNATIVE ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_cell_source_id ( int p_layer , const Vector2i & p_coords , bool p_use_proxies ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , LayeredTileSet : : INVALID_SOURCE , get_cell_source_id , p_coords , p_use_proxies ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
Vector2i LayeredTileMap : : get_cell_atlas_coords ( int p_layer , const Vector2i & p_coords , bool p_use_proxies ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , LayeredTileSetSource : : INVALID_ATLAS_COORDS , get_cell_atlas_coords , p_coords , p_use_proxies ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_cell_alternative_tile ( int p_layer , const Vector2i & p_coords , bool p_use_proxies ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , LayeredTileSetSource : : INVALID_TILE_ALTERNATIVE , get_cell_alternative_tile , p_coords , p_use_proxies ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-02 14:30:29 +01:00
LayeredTileData * LayeredTileMap : : get_cell_tile_data ( int p_layer , const Vector2i & p_coords , bool p_use_proxies ) const {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , nullptr , get_cell_tile_data , p_coords , p_use_proxies ) ;
}
2024-03-02 08:11:38 +01:00
Ref < LayeredTileMapPattern > LayeredTileMap : : get_pattern ( int p_layer , PoolVector2iArray p_coords_array ) {
2024-03-01 15:36:53 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , Ref < LayeredTileMapPattern > ( ) , get_pattern , p_coords_array ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
Vector2i LayeredTileMap : : map_pattern ( const Vector2i & p_position_in_tilemap , const Vector2i & p_coords_in_pattern , Ref < LayeredTileMapPattern > p_pattern ) {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND_V ( ! tile_set . is_valid ( ) , Vector2i ( ) ) ;
return tile_set - > map_pattern ( p_position_in_tilemap , p_coords_in_pattern , p_pattern ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_pattern ( int p_layer , const Vector2i & p_position , const Ref < LayeredTileMapPattern > p_pattern ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_pattern , p_position , p_pattern ) ;
}
2024-03-01 15:36:53 +01:00
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > LayeredTileMap : : terrain_fill_constraints ( int p_layer , const Vector < Vector2i > & p_to_replace , int p_terrain_set , const RBSet < TerrainConstraint > & p_constraints ) {
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > err_value ;
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , err_value , terrain_fill_constraints , p_to_replace , p_terrain_set , p_constraints ) ;
}
2024-03-01 15:36:53 +01:00
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > LayeredTileMap : : 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 , LayeredTileSet : : TerrainsPattern > err_value ;
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , err_value , terrain_fill_connect , p_coords_array , p_terrain_set , p_terrain , p_ignore_empty_terrains ) ;
}
2024-03-01 15:36:53 +01:00
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > LayeredTileMap : : 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 , LayeredTileSet : : TerrainsPattern > err_value ;
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , err_value , terrain_fill_path , p_coords_array , p_terrain_set , p_terrain , p_ignore_empty_terrains ) ;
}
2024-03-01 15:36:53 +01:00
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > LayeredTileMap : : terrain_fill_pattern ( int p_layer , const Vector < Vector2i > & p_coords_array , int p_terrain_set , LayeredTileSet : : TerrainsPattern p_terrains_pattern , bool p_ignore_empty_terrains ) {
HashMap < Vector2i , LayeredTileSet : : TerrainsPattern > err_value ;
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER_V ( p_layer , err_value , terrain_fill_pattern , p_coords_array , p_terrain_set , p_terrains_pattern , p_ignore_empty_terrains ) ;
}
2024-03-02 08:11:38 +01:00
void LayeredTileMap : : set_cells_terrain_connect ( int p_layer , PoolVector2iArray p_cells , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_cells_terrain_connect , p_cells , p_terrain_set , p_terrain , p_ignore_empty_terrains ) ;
}
2024-03-02 08:11:38 +01:00
void LayeredTileMap : : set_cells_terrain_path ( int p_layer , PoolVector2iArray p_path , int p_terrain_set , int p_terrain , bool p_ignore_empty_terrains ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , set_cells_terrain_path , p_path , p_terrain_set , p_terrain , p_ignore_empty_terrains ) ;
}
2024-03-01 15:36:53 +01:00
LayeredTileMapCell LayeredTileMap : : get_cell ( int p_layer , const Vector2i & p_coords , bool p_use_proxies ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , LayeredTileMapCell ( ) , get_cell , p_coords , p_use_proxies ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
Vector2i LayeredTileMap : : get_coords_for_body_rid ( RID p_physics_body ) {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
if ( layer - > has_body_rid ( p_physics_body ) ) {
return layer - > get_coords_for_body_rid ( p_physics_body ) ;
}
}
2024-03-03 09:39:24 +01:00
2024-03-01 10:38:08 +01:00
ERR_FAIL_V_MSG ( Vector2i ( ) , vformat ( " No tiles for the given body RID %d. " , p_physics_body . get_id ( ) ) ) ;
}
2024-03-01 15:36:53 +01:00
int LayeredTileMap : : get_layer_for_body_rid ( RID p_physics_body ) {
2024-03-01 10:38:08 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; i + + ) {
if ( layers [ i ] - > has_body_rid ( p_physics_body ) ) {
return i ;
}
}
ERR_FAIL_V_MSG ( - 1 , vformat ( " No tiles for the given body RID %d. " , p_physics_body . get_id ( ) ) ) ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : fix_invalid_tiles ( ) {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > fix_invalid_tiles ( ) ;
}
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : clear_layer ( int p_layer ) {
2024-03-01 10:38:08 +01:00
TILEMAP_CALL_FOR_LAYER ( p_layer , clear )
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : clear ( ) {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > clear ( ) ;
}
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : update_internals ( ) {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > update_internals ( ) ;
}
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : notify_runtime_tile_data_update ( int p_layer ) {
2024-03-01 10:38:08 +01:00
if ( p_layer > = 0 ) {
TILEMAP_CALL_FOR_LAYER ( p_layer , notify_runtime_tile_data_update ) ;
} else {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > notify_runtime_tile_data_update ( ) ;
}
}
}
# ifdef TOOLS_ENABLED
2024-03-01 15:36:53 +01:00
Rect2 LayeredTileMap : : _edit_get_rect ( ) const {
2024-03-01 10:38:08 +01:00
// Return the visible rect of the tilemap.
2024-03-02 09:13:07 +01:00
if ( layers . empty ( ) ) {
2024-03-01 10:38:08 +01:00
return Rect2 ( ) ;
}
bool any_changed = false ;
bool changed = false ;
Rect2 rect = layers [ 0 ] - > get_rect ( changed ) ;
any_changed | = changed ;
for ( uint32_t i = 1 ; i < layers . size ( ) ; i + + ) {
rect = rect . merge ( layers [ i ] - > get_rect ( changed ) ) ;
any_changed | = changed ;
}
2024-03-01 15:36:53 +01:00
const_cast < LayeredTileMap * > ( this ) - > item_rect_changed ( any_changed ) ;
2024-03-01 10:38:08 +01:00
return rect ;
}
# endif
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : _set ( const StringName & p_name , const Variant & p_value ) {
2024-03-01 10:38:08 +01:00
Vector < String > components = String ( p_name ) . split ( " / " , true , 2 ) ;
if ( p_name = = " format " ) {
if ( p_value . get_type ( ) = = Variant : : INT ) {
2024-03-01 15:36:53 +01:00
format = ( LayeredTileMapDataFormat ) ( p_value . operator int64_t ( ) ) ; // Set format used for loading.
2024-03-01 10:38:08 +01:00
return true ;
}
}
# ifndef DISABLE_DEPRECATED
else if ( p_name = = " tile_data " ) { // Kept for compatibility reasons.
if ( p_value . is_array ( ) ) {
if ( layers . size ( ) = = 0 ) {
2024-03-01 15:36:53 +01:00
LayeredTileMapLayer * new_layer = memnew ( LayeredTileMapLayer ) ;
2024-03-03 09:39:24 +01:00
add_child ( new_layer ) ;
move_child ( new_layer , 0 ) ;
2024-03-01 10:38:08 +01:00
new_layer - > set_as_tile_map_internal_node ( 0 ) ;
new_layer - > set_name ( " Layer0 " ) ;
2024-03-03 09:39:24 +01:00
new_layer - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _emit_changed " ) ;
2024-03-01 10:38:08 +01:00
layers . push_back ( new_layer ) ;
}
layers [ 0 ] - > set_tile_data ( format , p_value ) ;
_emit_changed ( ) ;
return true ;
}
return false ;
} else if ( p_name = = " cell_quadrant_size " ) {
set_rendering_quadrant_size ( p_value ) ;
return true ;
}
# endif // DISABLE_DEPRECATED
2024-03-02 11:03:29 +01:00
else if ( components . size ( ) = = 2 & & components [ 0 ] . begins_with ( " layer_ " ) & & components [ 0 ] . trim_prefix ( " layer_ " ) . is_valid_integer ( ) ) {
2024-03-01 10:38:08 +01:00
int index = components [ 0 ] . trim_prefix ( " layer_ " ) . to_int ( ) ;
if ( index < 0 ) {
return false ;
}
if ( index > = ( int ) layers . size ( ) ) {
while ( index > = ( int ) layers . size ( ) ) {
2024-03-01 15:36:53 +01:00
LayeredTileMapLayer * new_layer = memnew ( LayeredTileMapLayer ) ;
2024-03-03 09:39:24 +01:00
add_child ( new_layer ) ;
move_child ( new_layer , 0 ) ;
2024-03-01 10:38:08 +01:00
new_layer - > set_as_tile_map_internal_node ( index ) ;
new_layer - > set_name ( vformat ( " Layer%d " , index ) ) ;
2024-03-03 09:39:24 +01:00
new_layer - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _emit_changed " ) ;
2024-03-01 10:38:08 +01:00
layers . push_back ( new_layer ) ;
}
2024-03-02 09:13:07 +01:00
property_list_changed_notify ( ) ;
2024-03-01 10:38:08 +01:00
_emit_changed ( ) ;
2024-03-03 09:39:24 +01:00
update_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
}
if ( components [ 1 ] = = " name " ) {
set_layer_name ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " enabled " ) {
set_layer_enabled ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " modulate " ) {
set_layer_modulate ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " y_sort_enabled " ) {
set_layer_y_sort_enabled ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " y_sort_origin " ) {
set_layer_y_sort_origin ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " z_index " ) {
set_layer_z_index ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " navigation_enabled " ) {
set_layer_navigation_enabled ( index , p_value ) ;
return true ;
} else if ( components [ 1 ] = = " tile_data " ) {
layers [ index ] - > set_tile_data ( format , p_value ) ;
_emit_changed ( ) ;
return true ;
} else {
return false ;
}
}
return false ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : _get ( const StringName & p_name , Variant & r_ret ) const {
2024-03-01 10:38:08 +01:00
Vector < String > components = String ( p_name ) . split ( " / " , true , 2 ) ;
if ( p_name = = " format " ) {
2024-03-01 15:36:53 +01:00
r_ret = LayeredTileMapDataFormat : : FORMAT_MAX - 1 ; // When saving, always save highest format.
2024-03-01 10:38:08 +01:00
return true ;
}
# ifndef DISABLE_DEPRECATED
else if ( p_name = = " cell_quadrant_size " ) { // Kept for compatibility reasons.
r_ret = get_rendering_quadrant_size ( ) ;
return true ;
}
# endif
2024-03-02 11:03:29 +01:00
else if ( components . size ( ) = = 2 & & components [ 0 ] . begins_with ( " layer_ " ) & & components [ 0 ] . trim_prefix ( " layer_ " ) . is_valid_integer ( ) ) {
2024-03-01 10:38:08 +01:00
int index = components [ 0 ] . trim_prefix ( " layer_ " ) . to_int ( ) ;
if ( index < 0 | | index > = ( int ) layers . size ( ) ) {
return false ;
}
if ( components [ 1 ] = = " name " ) {
r_ret = get_layer_name ( index ) ;
return true ;
} else if ( components [ 1 ] = = " enabled " ) {
r_ret = is_layer_enabled ( index ) ;
return true ;
} else if ( components [ 1 ] = = " modulate " ) {
r_ret = get_layer_modulate ( index ) ;
return true ;
} else if ( components [ 1 ] = = " y_sort_enabled " ) {
r_ret = is_layer_y_sort_enabled ( index ) ;
return true ;
} else if ( components [ 1 ] = = " y_sort_origin " ) {
r_ret = get_layer_y_sort_origin ( index ) ;
return true ;
} else if ( components [ 1 ] = = " z_index " ) {
r_ret = get_layer_z_index ( index ) ;
return true ;
} else if ( components [ 1 ] = = " navigation_enabled " ) {
r_ret = is_layer_navigation_enabled ( index ) ;
return true ;
} else if ( components [ 1 ] = = " tile_data " ) {
r_ret = layers [ index ] - > get_tile_data ( ) ;
return true ;
} else {
return false ;
}
}
return false ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : _get_property_list ( List < PropertyInfo > * p_list ) const {
2024-03-02 19:29:43 +01:00
p_list - > push_back ( PropertyInfo ( Variant : : INT , " format " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) ) ;
2024-03-01 10:38:08 +01:00
p_list - > push_back ( PropertyInfo ( Variant : : NIL , " Layers " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_GROUP ) ) ;
2024-03-03 09:39:24 +01:00
# define MAKE_LAYER_PROPERTY(m_type, m_name, m_hint) \
{ \
const String property_name = vformat ( " layer_%d/ " m_name , i ) ; \
p_list - > push_back ( PropertyInfo ( m_type , property_name , PROPERTY_HINT_NONE , m_hint , PROPERTY_USAGE_DEFAULT ) ) ; \
2024-03-01 10:38:08 +01:00
}
for ( uint32_t i = 0 ; i < layers . size ( ) ; i + + ) {
MAKE_LAYER_PROPERTY ( Variant : : STRING , " name " , " " ) ;
MAKE_LAYER_PROPERTY ( Variant : : BOOL , " enabled " , " " ) ;
MAKE_LAYER_PROPERTY ( Variant : : COLOR , " modulate " , " " ) ;
MAKE_LAYER_PROPERTY ( Variant : : BOOL , " y_sort_enabled " , " " ) ;
MAKE_LAYER_PROPERTY ( Variant : : INT , " y_sort_origin " , " suffix:px " ) ;
MAKE_LAYER_PROPERTY ( Variant : : INT , " z_index " , " " ) ;
MAKE_LAYER_PROPERTY ( Variant : : BOOL , " navigation_enabled " , " " ) ;
2024-03-02 19:29:43 +01:00
p_list - > push_back ( PropertyInfo ( Variant : : OBJECT , vformat ( " layer_%d/tile_data " , i ) , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
2024-03-01 10:38:08 +01:00
}
# undef MAKE_LAYER_PROPERTY
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : _property_can_revert ( const StringName & p_name ) const {
2024-03-01 10:38:08 +01:00
Vector < String > components = String ( p_name ) . split ( " / " , true , 2 ) ;
if ( components . size ( ) = = 2 & & components [ 0 ] . begins_with ( " layer_ " ) ) {
int index = components [ 0 ] . trim_prefix ( " layer_ " ) . to_int ( ) ;
if ( index < = 0 | | index > = ( int ) layers . size ( ) ) {
return false ;
}
if ( components [ 1 ] = = " name " ) {
return layers [ index ] - > get_name ( ) ! = default_layer - > get_name ( ) ;
} else if ( components [ 1 ] = = " enabled " ) {
return layers [ index ] - > is_enabled ( ) ! = default_layer - > is_enabled ( ) ;
} else if ( components [ 1 ] = = " modulate " ) {
return layers [ index ] - > get_modulate ( ) ! = default_layer - > get_modulate ( ) ;
} else if ( components [ 1 ] = = " y_sort_enabled " ) {
2024-03-03 09:39:24 +01:00
return layers [ index ] - > is_sort_enabled ( ) ! = default_layer - > is_sort_enabled ( ) ;
2024-03-01 10:38:08 +01:00
} else if ( components [ 1 ] = = " y_sort_origin " ) {
return layers [ index ] - > get_y_sort_origin ( ) ! = default_layer - > get_y_sort_origin ( ) ;
} else if ( components [ 1 ] = = " z_index " ) {
return layers [ index ] - > get_z_index ( ) ! = default_layer - > get_z_index ( ) ;
} else if ( components [ 1 ] = = " navigation_enabled " ) {
return layers [ index ] - > is_navigation_enabled ( ) ! = default_layer - > is_navigation_enabled ( ) ;
}
}
return false ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : _property_get_revert ( const StringName & p_name , Variant & r_property ) const {
2024-03-01 10:38:08 +01:00
Vector < String > components = String ( p_name ) . split ( " / " , true , 2 ) ;
if ( components . size ( ) = = 2 & & components [ 0 ] . begins_with ( " layer_ " ) ) {
int index = components [ 0 ] . trim_prefix ( " layer_ " ) . to_int ( ) ;
if ( index < = 0 | | index > = ( int ) layers . size ( ) ) {
return false ;
}
if ( components [ 1 ] = = " name " ) {
r_property = default_layer - > get_name ( ) ;
return true ;
} else if ( components [ 1 ] = = " enabled " ) {
r_property = default_layer - > is_enabled ( ) ;
return true ;
} else if ( components [ 1 ] = = " modulate " ) {
r_property = default_layer - > get_modulate ( ) ;
return true ;
} else if ( components [ 1 ] = = " y_sort_enabled " ) {
2024-03-03 09:39:24 +01:00
r_property = default_layer - > is_sort_enabled ( ) ;
2024-03-01 10:38:08 +01:00
return true ;
} else if ( components [ 1 ] = = " y_sort_origin " ) {
r_property = default_layer - > get_y_sort_origin ( ) ;
return true ;
} else if ( components [ 1 ] = = " z_index " ) {
r_property = default_layer - > get_z_index ( ) ;
return true ;
} else if ( components [ 1 ] = = " navigation_enabled " ) {
r_property = default_layer - > is_navigation_enabled ( ) ;
return true ;
}
}
return false ;
}
2024-03-01 15:36:53 +01:00
Vector2 LayeredTileMap : : map_to_local ( const Vector2i & p_pos ) const {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND_V ( ! tile_set . is_valid ( ) , Vector2 ( ) ) ;
return tile_set - > map_to_local ( p_pos ) ;
}
2024-03-01 15:36:53 +01:00
Vector2i LayeredTileMap : : local_to_map ( const Vector2 & p_pos ) const {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND_V ( ! tile_set . is_valid ( ) , Vector2i ( ) ) ;
return tile_set - > local_to_map ( p_pos ) ;
}
2024-03-01 15:36:53 +01:00
bool LayeredTileMap : : is_existing_neighbor ( LayeredTileSet : : CellNeighbor p_cell_neighbor ) const {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND_V ( ! tile_set . is_valid ( ) , false ) ;
return tile_set - > is_existing_neighbor ( p_cell_neighbor ) ;
}
2024-03-01 15:36:53 +01:00
Vector2i LayeredTileMap : : get_neighbor_cell ( const Vector2i & p_coords , LayeredTileSet : : CellNeighbor p_cell_neighbor ) const {
2024-03-01 10:38:08 +01:00
ERR_FAIL_COND_V ( ! tile_set . is_valid ( ) , Vector2i ( ) ) ;
return tile_set - > get_neighbor_cell ( p_coords , p_cell_neighbor ) ;
}
2024-03-02 08:11:38 +01:00
PoolVector2iArray LayeredTileMap : : get_used_cells ( int p_layer ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , PoolVector2iArray ( ) , get_used_cells ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-02 08:11:38 +01:00
PoolVector2iArray LayeredTileMap : : get_used_cells_by_id ( int p_layer , int p_source_id , const Vector2i p_atlas_coords , int p_alternative_tile ) const {
TILEMAP_CALL_FOR_LAYER_V ( p_layer , PoolVector2iArray ( ) , get_used_cells_by_id , p_source_id , p_atlas_coords , p_alternative_tile ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
Rect2i LayeredTileMap : : get_used_rect ( ) const {
2024-03-01 10:38:08 +01:00
// Return the visible rect of the tilemap.
bool first = true ;
Rect2i rect = Rect2i ( ) ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
Rect2i layer_rect = layer - > get_used_rect ( ) ;
if ( layer_rect = = Rect2i ( ) ) {
continue ;
}
if ( first ) {
rect = layer_rect ;
first = false ;
} else {
rect = rect . merge ( layer_rect ) ;
}
}
return rect ;
}
// --- Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems ---
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_light_mask ( int p_light_mask ) {
2024-03-01 10:38:08 +01:00
// Set light mask for occlusion and applies it to all layers too.
CanvasItem : : set_light_mask ( p_light_mask ) ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > set_light_mask ( p_light_mask ) ;
}
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : set_self_modulate ( const Color & p_self_modulate ) {
2024-03-01 10:38:08 +01:00
// Set self_modulation and applies it to all layers too.
CanvasItem : : set_self_modulate ( p_self_modulate ) ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
LayeredTileMapLayer * layer = layers [ i ] ;
2024-03-01 10:38:08 +01:00
layer - > set_self_modulate ( p_self_modulate ) ;
}
}
2024-03-02 08:11:38 +01:00
PoolVector2iArray LayeredTileMap : : get_surrounding_cells ( const Vector2i & p_coords ) {
2024-03-01 10:38:08 +01:00
if ( ! tile_set . is_valid ( ) ) {
2024-03-02 08:11:38 +01:00
return PoolVector2iArray ( ) ;
2024-03-01 10:38:08 +01:00
}
return tile_set - > get_surrounding_cells ( p_coords ) ;
}
2024-03-03 11:46:07 +01:00
bool LayeredTileMap : : use_tile_data_runtime_update ( const int p_layer , const Vector2i & p_coords ) {
return call ( " _use_tile_data_runtime_update " , p_layer , p_coords ) ;
2024-03-03 09:39:24 +01:00
}
2024-03-03 11:46:07 +01:00
void LayeredTileMap : : tile_data_runtime_update ( const int p_layer , const Vector2i & p_coords , LayeredTileData * p_tile_data ) {
call ( " _tile_data_runtime_update " , p_layer , p_coords , p_tile_data ) ;
2024-03-03 09:39:24 +01:00
}
String LayeredTileMap : : get_configuration_warning ( ) const {
String warnings = Node : : get_configuration_warning ( ) ;
2024-03-01 10:38:08 +01:00
// Retrieve the set of Z index values with a Y-sorted layer.
RBSet < int > y_sorted_z_index ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
if ( layer - > is_sort_enabled ( ) ) {
2024-03-01 10:38:08 +01:00
y_sorted_z_index . insert ( layer - > get_z_index ( ) ) ;
}
}
// Check if we have a non-sorted layer in a Z-index with a Y-sorted layer.
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
if ( ! layer - > is_sort_enabled ( ) & & y_sorted_z_index . has ( layer - > get_z_index ( ) ) ) {
warnings + = RTR ( " A Y-sorted layer has the same Z-index value as a not Y-sorted layer. \n This may lead to unwanted behaviors, as a layer that is not Y-sorted will be Y-sorted as a whole with tiles from Y-sorted layers. " ) + " \n " ;
2024-03-01 10:38:08 +01:00
break ;
}
}
2024-03-03 09:39:24 +01:00
if ( ! is_sort_enabled ( ) ) {
2024-03-01 10:38:08 +01:00
// Check if Y-sort is enabled on a layer but not on the node.
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
if ( layer - > is_sort_enabled ( ) ) {
warnings + = RTR ( " A LayeredTileMap layer is set as Y-sorted, but Y-sort is not enabled on the LayeredTileMap node itself. " ) + " \n " ;
2024-03-01 10:38:08 +01:00
break ;
}
}
} else {
// Check if Y-sort is enabled on the node, but not on any of the layers.
bool need_warning = true ;
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
if ( layer - > is_sort_enabled ( ) ) {
2024-03-01 10:38:08 +01:00
need_warning = false ;
break ;
}
}
if ( need_warning ) {
2024-03-03 09:39:24 +01:00
warnings + = RTR ( " The LayeredTileMap node is set as Y-sorted, but Y-sort is not enabled on any of the LayeredTileMap's layers. \n This may lead to unwanted behaviors, as a layer that is not Y-sorted will be Y-sorted as a whole. " ) + " \n " ;
2024-03-01 10:38:08 +01:00
}
}
// Check if we are in isometric mode without Y-sort enabled.
2024-03-01 15:36:53 +01:00
if ( tile_set . is_valid ( ) & & tile_set - > get_tile_shape ( ) = = LayeredTileSet : : TILE_SHAPE_ISOMETRIC ) {
2024-03-03 09:39:24 +01:00
bool warn = ! is_sort_enabled ( ) ;
2024-03-01 10:38:08 +01:00
if ( ! warn ) {
2024-03-03 09:39:24 +01:00
for ( uint32_t i = 0 ; i < layers . size ( ) ; + + i ) {
const LayeredTileMapLayer * layer = layers [ i ] ;
if ( ! layer - > is_sort_enabled ( ) ) {
2024-03-01 10:38:08 +01:00
warn = true ;
break ;
}
}
}
if ( warn ) {
2024-03-03 09:39:24 +01:00
warnings + = RTR ( " Isometric LayeredTileSet will likely not look as intended without Y-sort enabled for the LayeredTileMap and all of its layers. " ) + " \n " ;
2024-03-01 10:38:08 +01:00
}
}
return warnings ;
}
2024-03-01 15:36:53 +01:00
void LayeredTileMap : : _bind_methods ( ) {
2024-03-01 10:38:08 +01:00
# ifndef DISABLE_DEPRECATED
2024-03-01 15:36:53 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_navigation_map " , " layer " , " map " ) , & LayeredTileMap : : set_layer_navigation_map ) ;
ClassDB : : bind_method ( D_METHOD ( " get_navigation_map " , " layer " ) , & LayeredTileMap : : get_layer_navigation_map ) ;
ClassDB : : bind_method ( D_METHOD ( " force_update " , " layer " ) , & LayeredTileMap : : force_update , DEFVAL ( - 1 ) ) ;
2024-03-01 10:38:08 +01:00
# endif // DISABLE_DEPRECATED
2024-03-01 15:36:53 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_rendering_quadrant_size " , " size " ) , & LayeredTileMap : : set_rendering_quadrant_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_rendering_quadrant_size " ) , & LayeredTileMap : : get_rendering_quadrant_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layers_count " ) , & LayeredTileMap : : get_layers_count ) ;
ClassDB : : bind_method ( D_METHOD ( " add_layer " , " to_position " ) , & LayeredTileMap : : add_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " move_layer " , " layer " , " to_position " ) , & LayeredTileMap : : move_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_layer " , " layer " ) , & LayeredTileMap : : remove_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_name " , " layer " , " name " ) , & LayeredTileMap : : set_layer_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_name " , " layer " ) , & LayeredTileMap : : get_layer_name ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_enabled " , " layer " , " enabled " ) , & LayeredTileMap : : set_layer_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " is_layer_enabled " , " layer " ) , & LayeredTileMap : : is_layer_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_modulate " , " layer " , " modulate " ) , & LayeredTileMap : : set_layer_modulate ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_modulate " , " layer " ) , & LayeredTileMap : : get_layer_modulate ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_y_sort_enabled " , " layer " , " y_sort_enabled " ) , & LayeredTileMap : : set_layer_y_sort_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " is_layer_y_sort_enabled " , " layer " ) , & LayeredTileMap : : is_layer_y_sort_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_y_sort_origin " , " layer " , " y_sort_origin " ) , & LayeredTileMap : : set_layer_y_sort_origin ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_y_sort_origin " , " layer " ) , & LayeredTileMap : : get_layer_y_sort_origin ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_z_index " , " layer " , " z_index " ) , & LayeredTileMap : : set_layer_z_index ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_z_index " , " layer " ) , & LayeredTileMap : : get_layer_z_index ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_navigation_enabled " , " layer " , " enabled " ) , & LayeredTileMap : : set_layer_navigation_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " is_layer_navigation_enabled " , " layer " ) , & LayeredTileMap : : is_layer_navigation_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_layer_navigation_map " , " layer " , " map " ) , & LayeredTileMap : : set_layer_navigation_map ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_navigation_map " , " layer " ) , & LayeredTileMap : : get_layer_navigation_map ) ;
ClassDB : : bind_method ( D_METHOD ( " set_collision_animatable " , " enabled " ) , & LayeredTileMap : : set_collision_animatable ) ;
ClassDB : : bind_method ( D_METHOD ( " is_collision_animatable " ) , & LayeredTileMap : : is_collision_animatable ) ;
ClassDB : : bind_method ( D_METHOD ( " set_collision_visibility_mode " , " collision_visibility_mode " ) , & LayeredTileMap : : set_collision_visibility_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " get_collision_visibility_mode " ) , & LayeredTileMap : : get_collision_visibility_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " set_navigation_visibility_mode " , " navigation_visibility_mode " ) , & LayeredTileMap : : set_navigation_visibility_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " get_navigation_visibility_mode " ) , & LayeredTileMap : : get_navigation_visibility_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " set_cell " , " layer " , " coords " , " source_id " , " atlas_coords " , " alternative_tile " ) , & LayeredTileMap : : set_cell , DEFVAL ( LayeredTileSet : : INVALID_SOURCE ) , DEFVAL ( LayeredTileSetSource : : INVALID_ATLAS_COORDS ) , DEFVAL ( 0 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " erase_cell " , " layer " , " coords " ) , & LayeredTileMap : : erase_cell ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cell_source_id " , " layer " , " coords " , " use_proxies " ) , & LayeredTileMap : : get_cell_source_id , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cell_atlas_coords " , " layer " , " coords " , " use_proxies " ) , & LayeredTileMap : : get_cell_atlas_coords , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cell_alternative_tile " , " layer " , " coords " , " use_proxies " ) , & LayeredTileMap : : get_cell_alternative_tile , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cell_tile_data " , " layer " , " coords " , " use_proxies " ) , & LayeredTileMap : : get_cell_tile_data , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_coords_for_body_rid " , " body " ) , & LayeredTileMap : : get_coords_for_body_rid ) ;
ClassDB : : bind_method ( D_METHOD ( " get_layer_for_body_rid " , " body " ) , & LayeredTileMap : : get_layer_for_body_rid ) ;
ClassDB : : bind_method ( D_METHOD ( " get_pattern " , " layer " , " coords_array " ) , & LayeredTileMap : : get_pattern ) ;
ClassDB : : bind_method ( D_METHOD ( " map_pattern " , " position_in_tilemap " , " coords_in_pattern " , " pattern " ) , & LayeredTileMap : : map_pattern ) ;
ClassDB : : bind_method ( D_METHOD ( " set_pattern " , " layer " , " position " , " pattern " ) , & LayeredTileMap : : set_pattern ) ;
ClassDB : : bind_method ( D_METHOD ( " set_cells_terrain_connect " , " layer " , " cells " , " terrain_set " , " terrain " , " ignore_empty_terrains " ) , & LayeredTileMap : : set_cells_terrain_connect , DEFVAL ( true ) ) ;
ClassDB : : bind_method ( D_METHOD ( " set_cells_terrain_path " , " layer " , " path " , " terrain_set " , " terrain " , " ignore_empty_terrains " ) , & LayeredTileMap : : set_cells_terrain_path , DEFVAL ( true ) ) ;
ClassDB : : bind_method ( D_METHOD ( " fix_invalid_tiles " ) , & LayeredTileMap : : fix_invalid_tiles ) ;
ClassDB : : bind_method ( D_METHOD ( " clear_layer " , " layer " ) , & LayeredTileMap : : clear_layer ) ;
ClassDB : : bind_method ( D_METHOD ( " clear " ) , & LayeredTileMap : : clear ) ;
ClassDB : : bind_method ( D_METHOD ( " update_internals " ) , & LayeredTileMap : : update_internals ) ;
ClassDB : : bind_method ( D_METHOD ( " notify_runtime_tile_data_update " , " layer " ) , & LayeredTileMap : : notify_runtime_tile_data_update , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_surrounding_cells " , " coords " ) , & LayeredTileMap : : get_surrounding_cells ) ;
ClassDB : : bind_method ( D_METHOD ( " get_used_cells " , " layer " ) , & LayeredTileMap : : get_used_cells ) ;
ClassDB : : bind_method ( D_METHOD ( " get_used_cells_by_id " , " layer " , " source_id " , " atlas_coords " , " alternative_tile " ) , & LayeredTileMap : : get_used_cells_by_id , DEFVAL ( LayeredTileSet : : INVALID_SOURCE ) , DEFVAL ( LayeredTileSetSource : : INVALID_ATLAS_COORDS ) , DEFVAL ( LayeredTileSetSource : : INVALID_TILE_ALTERNATIVE ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_used_rect " ) , & LayeredTileMap : : get_used_rect ) ;
ClassDB : : bind_method ( D_METHOD ( " map_to_local " , " map_position " ) , & LayeredTileMap : : map_to_local ) ;
ClassDB : : bind_method ( D_METHOD ( " local_to_map " , " local_position " ) , & LayeredTileMap : : local_to_map ) ;
ClassDB : : bind_method ( D_METHOD ( " get_neighbor_cell " , " coords " , " neighbor " ) , & LayeredTileMap : : get_neighbor_cell ) ;
2024-03-01 10:38:08 +01:00
2024-03-03 09:39:24 +01:00
BIND_VMETHOD ( MethodInfo ( " _use_tile_data_runtime_update " ,
PropertyInfo ( Variant : : INT , " layer " ) ,
2024-03-03 11:46:07 +01:00
PropertyInfo ( Variant : : VECTOR2I , " coords " ) ) ) ;
2024-03-03 09:39:24 +01:00
BIND_VMETHOD ( MethodInfo ( " _tile_data_runtime_update " ,
PropertyInfo ( Variant : : INT , " layer " ) ,
2024-03-03 11:46:07 +01:00
PropertyInfo ( Variant : : VECTOR2I , " coords " ) ,
2024-03-03 09:39:24 +01:00
PropertyInfo ( Variant : : OBJECT , " tile_data " , PROPERTY_HINT_RESOURCE_TYPE , " LayeredTileData " ) ) ) ;
2024-03-03 12:59:36 +01:00
//ClassDB::bind_method(D_METHOD("use_tile_data_runtime_update", "layer", "coords"), &LayeredTileMap::use_tile_data_runtime_update);
//ClassDB::bind_method(D_METHOD("tile_data_runtime_update", "layer", "coords", "tile_data"), &LayeredTileMap::tile_data_runtime_update);
2024-03-03 09:39:24 +01:00
ClassDB : : bind_method ( D_METHOD ( " _emit_changed " ) , & LayeredTileMap : : _emit_changed ) ;
2024-03-01 10:38:08 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " rendering_quadrant_size " , PROPERTY_HINT_RANGE , " 1,128,1 " ) , " set_rendering_quadrant_size " , " get_rendering_quadrant_size " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " collision_animatable " ) , " set_collision_animatable " , " is_collision_animatable " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " collision_visibility_mode " , PROPERTY_HINT_ENUM , " Default,Force Show,Force Hide " ) , " set_collision_visibility_mode " , " get_collision_visibility_mode " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " navigation_visibility_mode " , PROPERTY_HINT_ENUM , " Default,Force Show,Force Hide " ) , " set_navigation_visibility_mode " , " get_navigation_visibility_mode " ) ;
ADD_ARRAY ( " layers " , " layer_ " ) ;
2024-03-01 15:36:53 +01:00
ADD_PROPERTY_DEFAULT ( " format " , LayeredTileMapDataFormat : : FORMAT_1 ) ;
2024-03-01 10:38:08 +01:00
ADD_SIGNAL ( MethodInfo ( CoreStringNames : : get_singleton ( ) - > changed ) ) ;
BIND_ENUM_CONSTANT ( VISIBILITY_MODE_DEFAULT ) ;
BIND_ENUM_CONSTANT ( VISIBILITY_MODE_FORCE_HIDE ) ;
BIND_ENUM_CONSTANT ( VISIBILITY_MODE_FORCE_SHOW ) ;
}
2024-03-01 15:36:53 +01:00
LayeredTileMap : : LayeredTileMap ( ) {
LayeredTileMapLayer * new_layer = memnew ( LayeredTileMapLayer ) ;
2024-03-03 09:39:24 +01:00
add_child ( new_layer ) ;
move_child ( new_layer , 0 ) ;
2024-03-01 10:38:08 +01:00
new_layer - > set_as_tile_map_internal_node ( 0 ) ;
new_layer - > set_name ( " Layer0 " ) ;
2024-03-03 09:39:24 +01:00
new_layer - > connect ( CoreStringNames : : get_singleton ( ) - > changed , this , " _emit_changed " ) ;
2024-03-01 10:38:08 +01:00
layers . push_back ( new_layer ) ;
2024-03-01 15:36:53 +01:00
default_layer = memnew ( LayeredTileMapLayer ) ;
2024-03-01 10:38:08 +01:00
}
2024-03-01 15:36:53 +01:00
LayeredTileMap : : ~ LayeredTileMap ( ) {
2024-03-01 10:38:08 +01:00
memdelete ( default_layer ) ;
}
# undef TILEMAP_CALL_FOR_LAYER
# undef TILEMAP_CALL_FOR_LAYER_V