tile_map_layer_editor.cpp | Explore in Territory

/**************************************************************************/
/*  tile_map_layer_editor.cpp                                             */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "tile_map_layer_editor.h"

#include "tiles_editor_plugin.h"

#include "editor/editor_node.h"
#include "editor/editor_resource_preview.h"
#include "editor/editor_settings.h"
#include "editor/editor_undo_redo_manager.h"
#include "editor/multi_node_edit.h"
#include "editor/plugins/canvas_item_editor_plugin.h"
#include "editor/themes/editor_scale.h"
#include "scene/2d/camera_2d.h"
#include "scene/2d/tile_map_layer.h"
#include "scene/gui/center_container.h"
#include "scene/gui/split_container.h"

#include "core/input/input.h"
#include "core/math/geometry_2d.h"
#include "core/os/keyboard.h"

TileMapLayer *TileMapLayerSubEditorPlugin::_get_edited_layer() const { … }

void TileMapLayerEditorTilesPlugin::tile_set_changed() { … }

void TileMapLayerEditorTilesPlugin::_on_random_tile_checkbox_toggled(bool p_pressed) { … }

void TileMapLayerEditorTilesPlugin::_on_scattering_spinbox_changed(double p_value) { … }

void TileMapLayerEditorTilesPlugin::_update_toolbar() { … }

void TileMapLayerEditorTilesPlugin::_update_transform_buttons() { … }

void TileMapLayerEditorTilesPlugin::_set_transform_buttons_state(const Vector<Button *> &p_enabled_buttons, const Vector<Button *> &p_disabled_buttons, const String &p_why_disabled) { … }

Vector<TileMapLayerSubEditorPlugin::TabData> TileMapLayerEditorTilesPlugin::get_tabs() const { … }

void TileMapLayerEditorTilesPlugin::_tab_changed() { … }

void TileMapLayerEditorTilesPlugin::_update_tile_set_sources_list() { … }

void TileMapLayerEditorTilesPlugin::_update_source_display() { … }

void TileMapLayerEditorTilesPlugin::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditorTilesPlugin::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Texture2D> p_texture) { … }

void TileMapLayerEditorTilesPlugin::_update_patterns_list() { … }

void TileMapLayerEditorTilesPlugin::_update_atlas_view() { … }

void TileMapLayerEditorTilesPlugin::_update_scenes_collection_view() { … }

void TileMapLayerEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, const Variant &p_ud) { … }

void TileMapLayerEditorTilesPlugin::_scenes_list_multi_selected(int p_index, bool p_selected) { … }

void TileMapLayerEditorTilesPlugin::_scenes_list_lmb_empty_clicked(const Vector2 &p_pos, MouseButton p_mouse_button_index) { … }

void TileMapLayerEditorTilesPlugin::_update_theme() { … }

bool TileMapLayerEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) { … }

void TileMapLayerEditorTilesPlugin::_mouse_exited_viewport() { … }

TileMapCell TileMapLayerEditorTilesPlugin::_pick_random_tile(Ref<TileMapPattern> p_pattern) { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTilesPlugin::_draw_line(Vector2 p_start_drag_mouse_pos, Vector2 p_from_mouse_pos, Vector2 p_to_mouse_pos, bool p_erase) { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTilesPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTilesPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) { … }

void TileMapLayerEditorTilesPlugin::_stop_dragging() { … }

void TileMapLayerEditorTilesPlugin::_apply_transform(int p_type) { … }

int TileMapLayerEditorTilesPlugin::_get_transformed_alternative(int p_alternative_id, int p_transform) { … }

void TileMapLayerEditorTilesPlugin::_update_fix_selected_and_hovered() { … }

void TileMapLayerEditorTilesPlugin::_fix_invalid_tiles_in_tile_map_selection() { … }
void TileMapLayerEditorTilesPlugin::patterns_item_list_empty_clicked(const Vector2 &p_pos, MouseButton p_mouse_button_index) { … }

void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilemap_selection() { … }

void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tileset_tiles_selection() { … }

void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection() { … }

void TileMapLayerEditorTilesPlugin::_update_tileset_selection_from_selection_pattern() { … }

void TileMapLayerEditorTilesPlugin::_tile_atlas_control_draw() { … }

void TileMapLayerEditorTilesPlugin::_tile_atlas_control_mouse_exited() { … }

void TileMapLayerEditorTilesPlugin::_tile_atlas_control_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditorTilesPlugin::_tile_alternatives_control_draw() { … }

void TileMapLayerEditorTilesPlugin::_tile_alternatives_control_mouse_exited() { … }

void TileMapLayerEditorTilesPlugin::_tile_alternatives_control_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditorTilesPlugin::_set_tile_map_selection(const TypedArray<Vector2i> &p_selection) { … }

TypedArray<Vector2i> TileMapLayerEditorTilesPlugin::_get_tile_map_selection() const { … }

void TileMapLayerEditorTilesPlugin::_set_source_sort(int p_sort) { … }

void TileMapLayerEditorTilesPlugin::_bind_methods() { … }

void TileMapLayerEditorTilesPlugin::edit(ObjectID p_tile_map_layer_id) { … }

TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { … }

TileMapLayerEditorTilesPlugin::~TileMapLayerEditorTilesPlugin() { … }

void TileMapLayerEditorTerrainsPlugin::tile_set_changed() { … }

void TileMapLayerEditorTerrainsPlugin::_update_toolbar() { … }

Vector<TileMapLayerSubEditorPlugin::TabData> TileMapLayerEditorTerrainsPlugin::get_tabs() const { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTerrainsPlugin::_draw_terrain_path_or_connect(const Vector<Vector2i> &p_to_paint, int p_terrain_set, int p_terrain, bool p_connect) const { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTerrainsPlugin::_draw_terrain_pattern(const Vector<Vector2i> &p_to_paint, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTerrainsPlugin::_draw_line(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTerrainsPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { … }

RBSet<Vector2i> TileMapLayerEditorTerrainsPlugin::_get_cells_for_bucket_fill(Vector2i p_coords, bool p_contiguous) { … }

HashMap<Vector2i, TileMapCell> TileMapLayerEditorTerrainsPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) { … }

void TileMapLayerEditorTerrainsPlugin::_stop_dragging() { … }

void TileMapLayerEditorTerrainsPlugin::_mouse_exited_viewport() { … }

void TileMapLayerEditorTerrainsPlugin::_update_selection() { … }

bool TileMapLayerEditorTerrainsPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) { … }

void TileMapLayerEditorTerrainsPlugin::_update_terrains_cache() { … }

void TileMapLayerEditorTerrainsPlugin::_update_terrains_tree() { … }

void TileMapLayerEditorTerrainsPlugin::_update_tiles_list() { … }

void TileMapLayerEditorTerrainsPlugin::_update_theme() { … }

void TileMapLayerEditorTerrainsPlugin::edit(ObjectID p_edited_tile_map_layer_id) { … }

TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { … }

TileMapLayerEditorTerrainsPlugin::~TileMapLayerEditorTerrainsPlugin() { … }

TileMapLayer *TileMapLayerEditor::_get_edited_layer() const { … }

void TileMapLayerEditor::_find_tile_map_layers_in_scene(Node *p_current, const Node *p_owner, Vector<TileMapLayer *> &r_list) const { … }

void TileMapLayerEditor::_update_tile_map_layers_in_scene_list_cache() { … }

void TileMapLayerEditor::_node_change(Node *p_node) { … }

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

void TileMapLayerEditor::_on_grid_toggled(bool p_pressed) { … }

void TileMapLayerEditor::_select_previous_layer_pressed() { … }

void TileMapLayerEditor::_select_next_layer_pressed() { … }

void TileMapLayerEditor::_select_all_layers_pressed() { … }

void TileMapLayerEditor::_layers_selection_item_selected(int p_index) { … }

void TileMapLayerEditor::_update_layers_selector() { … }

void TileMapLayerEditor::_clear_all_layers_highlighting() { … }

void TileMapLayerEditor::_update_all_layers_highlighting() { … }

void TileMapLayerEditor::_highlight_selected_layer_button_toggled(bool p_pressed) { … }

void TileMapLayerEditor::_advanced_menu_button_id_pressed(int p_id) { … }

void TileMapLayerEditor::_update_bottom_panel() { … }

Vector<Vector2i> TileMapLayerEditor::get_line(const TileMapLayer *p_tile_map_layer, Vector2i p_from_cell, Vector2i p_to_cell) { … }

void TileMapLayerEditor::_tile_map_layer_changed() { … }

void TileMapLayerEditor::_tab_changed(int p_tab_id) { … }

void TileMapLayerEditor::_layers_select_next_or_previous(bool p_next) { … }

void TileMapLayerEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_edited, const String &p_array_prefix, int p_from_index, int p_to_pos) { … }

bool TileMapLayerEditor::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { … }

void TileMapLayerEditor::forward_canvas_draw_over_viewport(Control *p_overlay) { … }

void TileMapLayerEditor::edit(Object *p_edited) { … }

void TileMapLayerEditor::set_show_layer_selector(bool p_show_layer_selector) { … }

TileMapLayerEditor::TileMapLayerEditor() { … }

TileMapLayerEditor::~TileMapLayerEditor() { … }
godot/editor/plugins/tiles/tile_map_layer_editor.cpp
