Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-02-02 22:35:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

Mass replaced some types in the layered tile map module.

Browse Source
This commit is contained in:
Relintai 2024-03-02 08:11:38 +01:00
parent 2b85fcdbb5
commit 962f1cb188
25 changed files with 251 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
modules/layered_tile_map/editor/atlas_merging_dialog.cpp
View File

@ -170,7 +170,7 @@ void AtlasMergingDialog::_update_texture() {
merge_button->set_disabled(false);
} else {
_generate_merged(Vector<Ref<LayeredTileSetAtlasSource>>(), next_line_after_column);
preview->set_texture(Ref<Texture2D>());
preview->set_texture(Ref<Texture>());
preview->hide();
select_2_atlases_label->show();
get_ok_button()->set_disabled(true);
@ -186,7 +186,7 @@ void AtlasMergingDialog::_merge_confirmed(const String &p_path) {
ResourceLoader::import(p_path);
Ref<Texture2D> new_texture_resource = ResourceLoader::load(p_path, "Texture2D");
Ref<Texture> new_texture_resource = ResourceLoader::load(p_path, "Texture2D");
merged->set_texture(new_texture_resource);
EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
@ -279,7 +279,7 @@ void AtlasMergingDialog::update_tile_set(Ref<LayeredTileSet> p_tile_set) {
int source_id = p_tile_set->get_source_id(i);
Ref<LayeredTileSetAtlasSource> atlas_source = p_tile_set->get_source(source_id);
if (atlas_source.is_valid()) {
Ref<Texture2D> texture = atlas_source->get_texture();
Ref<Texture> texture = atlas_source->get_texture();
if (texture.is_valid()) {
String item_text = vformat(TTR("%s (ID: %d)"), texture->get_path().get_file(), source_id);
atlas_merging_atlases_list->add_item(item_text, texture);

6
modules/layered_tile_map/editor/atlas_merging_dialog.h
View File

@ -70,9 +70,9 @@ private:
void _merge_confirmed(const String &p_path);
protected:
virtual void ok_pressed() override;
virtual void cancel_pressed() override;
virtual void custom_action(const String &) override;
virtual void ok_pressed();
virtual void cancel_pressed();
virtual void custom_action(const String &);
bool _set(const StringName &p_name, const Variant &p_value);
bool _get(const StringName &p_name, Variant &r_ret) const;

12
modules/layered_tile_map/editor/layered_tile_atlas_view.cpp
View File

@ -62,7 +62,7 @@ void LayeredTileAtlasView::_zoom_callback(float p_zoom_factor, Vector2 p_origin,
Size2i LayeredTileAtlasView::_compute_base_tiles_control_size() {
// Update the texture.
Vector2i size;
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) {
size = texture->get_size();
}
@ -100,7 +100,7 @@ void LayeredTileAtlasView::_update_zoom_and_panning(bool p_zoom_on_mouse_pos) {
alternative_tiles_root_control->set_custom_minimum_size(Vector2(alternative_tiles_control_size) * zoom);
// Set the texture for the base tiles.
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
// Set the scales.
if (base_tiles_control_size.x > 0 && base_tiles_control_size.y > 0) {
@ -170,7 +170,7 @@ void LayeredTileAtlasView::_base_tiles_root_control_gui_input(const Ref<InputEve
}
void LayeredTileAtlasView::_draw_base_tiles() {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins();
Vector2i separation = tile_set_atlas_source->get_separation();
@ -315,7 +315,7 @@ void LayeredTileAtlasView::_clear_material_canvas_items() {
}
void LayeredTileAtlasView::_draw_base_tiles_texture_grid() {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins();
Vector2i separation = tile_set_atlas_source->get_separation();
@ -384,7 +384,7 @@ void LayeredTileAtlasView::_alternative_tiles_root_control_gui_input(const Ref<I
void LayeredTileAtlasView::_draw_alternatives() {
// Draw the alternative tiles.
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) {
Vector2 current_pos;
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
@ -486,7 +486,7 @@ void LayeredTileAtlasView::set_padding(Side p_side, int p_padding) {
}
Vector2i LayeredTileAtlasView::get_atlas_tile_coords_at_pos(const Vector2 p_pos, bool p_clamp) const {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (!texture.is_valid()) {
return LayeredTileSetSource::INVALID_ATLAS_COORDS;
}

8
modules/layered_tile_map/editor/layered_tile_atlas_view.h
View File

@ -63,7 +63,7 @@ private:
void _update_zoom_and_panning(bool p_zoom_on_mouse_pos = false);
void _zoom_widget_changed();
void _center_view();
virtual void gui_input(const Ref<InputEvent> &p_event) override;
virtual void gui_input(const Ref<InputEvent> &p_event);
Ref<ViewPanner> panner;
void _pan_callback(Vector2 p_scroll_vec, Ref<InputEvent> p_event);
@ -116,12 +116,12 @@ private:
Size2i _compute_alternative_tiles_control_size();
struct ThemeCache {
Ref<Texture2D> center_view_icon;
Ref<Texture2D> checkerboard;
Ref<Texture> center_view_icon;
Ref<Texture> checkerboard;
} theme_cache;
protected:
virtual void _update_theme_item_cache() override;
virtual void _update_theme_item_cache();
void _notification(int p_what);
static void _bind_methods();

18
modules/layered_tile_map/editor/layered_tile_data_editors.cpp
View File

@ -135,8 +135,8 @@ void GenericTilePolygonEditor::_base_control_draw() {
real_t grab_threshold = EDITOR_GET("editors/polygon_editor/point_grab_radius");
Color grid_color = EDITOR_GET("editors/tiles_editor/grid_color");
const Ref<Texture2D> handle = get_editor_theme_icon(SNAME("EditorPathSharpHandle"));
const Ref<Texture2D> add_handle = get_editor_theme_icon(SNAME("EditorHandleAdd"));
const Ref<Texture> handle = get_editor_theme_icon(SNAME("EditorPathSharpHandle"));
const Ref<Texture> add_handle = get_editor_theme_icon(SNAME("EditorHandleAdd"));
const Ref<StyleBox> focus_stylebox = get_theme_stylebox(SNAME("Focus"), EditorStringName(EditorStyles));
// Draw the focus rectangle.
@ -737,7 +737,7 @@ void GenericTilePolygonEditor::set_tile_set(Ref<LayeredTileSet> p_tile_set) {
_zoom_changed();
}
void GenericTilePolygonEditor::set_background(Ref<Texture2D> p_texture, Rect2 p_region, Vector2 p_offset, bool p_flip_h, bool p_flip_v, bool p_transpose, Color p_modulate) {
void GenericTilePolygonEditor::set_background(Ref<Texture> p_texture, Rect2 p_region, Vector2 p_offset, bool p_flip_h, bool p_flip_v, bool p_transpose, Color p_modulate) {
background_texture = p_texture;
background_region = p_region;
background_offset = p_offset;
@ -1205,7 +1205,7 @@ void TileDataDefaultEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2
Vector2 texture_origin = tile_data->get_texture_origin();
if (value.get_type() == Variant::BOOL) {
Ref<Texture2D> texture = (bool)value ? tile_bool_checked : tile_bool_unchecked;
Ref<Texture> texture = (bool)value ? tile_bool_checked : tile_bool_unchecked;
int size = MIN(tile_set->get_tile_size().x, tile_set->get_tile_size().y) / 3;
Rect2 rect = p_transform.xform(Rect2(Vector2(-size / 2, -size / 2) - texture_origin, Vector2(size, size)));
p_canvas_item->draw_texture_rect(texture, rect);
@ -1343,7 +1343,7 @@ void TileDataTextureOriginEditor::draw_over_tile(CanvasItem *p_canvas_item, Tran
}
if (atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, Vector2())) {
Ref<Texture2D> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
Ref<Texture> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2()) - (position_icon->get_size() / 2), color);
} else {
Ref<Font> font = LayeredTileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), EditorStringName(EditorFonts));
@ -1373,7 +1373,7 @@ void TileDataPositionEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
color = selection_color;
}
Ref<Texture2D> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
Ref<Texture> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(value)) - position_icon->get_size() / 2, color);
}
@ -1391,7 +1391,7 @@ void TileDataYSortEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2D
LayeredTileSetSource *source = *(tile_set->get_source(p_cell.source_id));
LayeredTileSetAtlasSource *atlas_source = Object::cast_to<LayeredTileSetAtlasSource>(source);
if (atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, Vector2(0, tile_data->get_y_sort_origin()))) {
Ref<Texture2D> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
Ref<Texture> position_icon = LayeredTileSetEditor::get_singleton()->get_editor_theme_icon(SNAME("EditorPosition"));
p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(0, tile_data->get_y_sort_origin())) - position_icon->get_size() / 2, color);
} else {
Ref<Font> font = LayeredTileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), EditorStringName(EditorFonts));
@ -1742,7 +1742,7 @@ void TileDataCollisionEditor::draw_over_tile(CanvasItem *p_canvas_item, Transfor
RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), p_transform);
Ref<Texture2D> one_way_icon = get_editor_theme_icon(SNAME("OneWayTile"));
Ref<Texture> one_way_icon = get_editor_theme_icon(SNAME("OneWayTile"));
for (int i = 0; i < tile_data->get_collision_polygons_count(physics_layer); i++) {
Vector<Vector2> polygon = tile_data->get_collision_polygon_points(physics_layer, i);
if (polygon.size() < 3) {
@ -1787,7 +1787,7 @@ void TileDataTerrainsEditor::_update_terrain_selector() {
terrain_property_editor->hide();
} else {
options.clear();
Vector<Vector<Ref<Texture2D>>> icons = tile_set->generate_terrains_icons(Size2(16, 16) * EDSCALE);
Vector<Vector<Ref<Texture>>> icons = tile_set->generate_terrains_icons(Size2(16, 16) * EDSCALE);
options.push_back(String(TTR("No terrain")) + String(":-1"));
for (int i = 0; i < tile_set->get_terrains_count(terrain_set); i++) {
String name = tile_set->get_terrain_name(terrain_set, i);

78
modules/layered_tile_map/editor/layered_tile_data_editors.h
View File

@ -142,7 +142,7 @@ private:
Button *button_center_view = nullptr;
Vector2 panning;
Ref<Texture2D> background_texture;
Ref<Texture> background_texture;
Rect2 background_region;
Vector2 background_offset;
bool background_h_flip = false;
@ -183,7 +183,7 @@ public:
void set_use_undo_redo(bool p_use_undo_redo);
void set_tile_set(Ref<LayeredTileSet> p_tile_set);
void set_background(Ref<Texture2D> p_texture, Rect2 p_region = Rect2(), Vector2 p_offset = Vector2(), bool p_flip_h = false, bool p_flip_v = false, bool p_transpose = false, Color p_modulate = Color(1.0, 1.0, 1.0, 0.0));
void set_background(Ref<Texture> p_texture, Rect2 p_region = Rect2(), Vector2 p_offset = Vector2(), bool p_flip_h = false, bool p_flip_v = false, bool p_transpose = false, Color p_modulate = Color(1.0, 1.0, 1.0, 0.0));
int get_polygon_count();
int add_polygon(const Vector<Point2> &p_polygon, int p_index = -1);
@ -207,8 +207,8 @@ private:
Button *picker_button = nullptr;
// UI
Ref<Texture2D> tile_bool_checked;
Ref<Texture2D> tile_bool_unchecked;
Ref<Texture> tile_bool_checked;
Ref<Texture> tile_bool_unchecked;
Label *label = nullptr;
EditorProperty *property_editor = nullptr;
@ -243,11 +243,11 @@ protected:
public:
virtual Control *get_toolbar() override { return toolbar; };
virtual void forward_draw_over_atlas(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_draw_over_alternatives(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_painting_atlas_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void forward_painting_alternatives_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void forward_draw_over_atlas(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform);
virtual void forward_draw_over_alternatives(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform);
virtual void forward_painting_atlas_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event);
virtual void forward_painting_alternatives_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event);
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
void setup_property_editor(Variant::Type p_type, const String &p_property, const String &p_label = "", const Variant &p_default_value = Variant());
Variant::Type get_property_type();
@ -260,21 +260,21 @@ class TileDataTextureOriginEditor : public TileDataDefaultEditor {
GDCLASS(TileDataTextureOriginEditor, TileDataDefaultEditor);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
};
class TileDataPositionEditor : public TileDataDefaultEditor {
GDCLASS(TileDataPositionEditor, TileDataDefaultEditor);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
};
class TileDataYSortEditor : public TileDataDefaultEditor {
GDCLASS(TileDataYSortEditor, TileDataDefaultEditor);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
};
class TileDataOcclusionShapeEditor : public TileDataDefaultEditor {
@ -288,19 +288,19 @@ private:
void _polygon_changed(const PackedVector2Array &p_polygon);
virtual Variant _get_painted_value() override;
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value) override;
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value) override;
virtual Variant _get_painted_value();
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value);
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value);
protected:
virtual void _tile_set_changed() override;
virtual void _tile_set_changed();
void _notification(int p_what);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
void set_occlusion_layer(int p_occlusion_layer) { occlusion_layer = p_occlusion_layer; }
@ -321,19 +321,19 @@ class TileDataCollisionEditor : public TileDataDefaultEditor {
void _property_selected(const StringName &p_path, int p_focusable);
void _polygons_changed();
virtual Variant _get_painted_value() override;
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value) override;
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value) override;
virtual Variant _get_painted_value();
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value);
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value);
protected:
virtual void _tile_set_changed() override;
virtual void _tile_set_changed();
void _notification(int p_what);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
void set_physics_layer(int p_physics_layer) { physics_layer = p_physics_layer; }
@ -374,17 +374,17 @@ private:
void _update_terrain_selector();
protected:
virtual void _tile_set_changed() override;
virtual void _tile_set_changed();
void _notification(int p_what);
public:
virtual Control *get_toolbar() override { return toolbar; };
virtual void forward_draw_over_atlas(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_draw_over_alternatives(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_painting_atlas_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void forward_painting_alternatives_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void forward_draw_over_atlas(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform);
virtual void forward_draw_over_alternatives(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform);
virtual void forward_painting_atlas_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event);
virtual void forward_painting_alternatives_gui_input(LayeredTileAtlasView *p_tile_atlas_view, LayeredTileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event);
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
TileDataTerrainsEditor();
~TileDataTerrainsEditor();
@ -402,19 +402,19 @@ private:
void _polygon_changed(const PackedVector2Array &p_polygon);
virtual Variant _get_painted_value() override;
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value) override;
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) override;
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value) override;
virtual Variant _get_painted_value();
virtual void _set_painted_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _set_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value);
virtual Variant _get_value(LayeredTileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile);
virtual void _setup_undo_redo_action(LayeredTileSetAtlasSource *p_tile_set_atlas_source, const HashMap<LayeredTileMapCell, Variant, LayeredTileMapCell> &p_previous_values, const Variant &p_new_value);
protected:
virtual void _tile_set_changed() override;
virtual void _tile_set_changed();
void _notification(int p_what);
public:
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, LayeredTileMapCell p_cell, bool p_selected = false);
void set_navigation_layer(int p_navigation_layer) { navigation_layer = p_navigation_layer; }

50
modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp
View File

@ -185,7 +185,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_tile_set_sources_list() {
for (const int &source_id : source_ids) {
LayeredTileSetSource *source = *tile_set->get_source(source_id);
Ref<Texture2D> texture;
Ref<Texture> texture;
String item_text;
// Common to all type of sources.
@ -333,7 +333,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_patterns_item_list_gui_input(const R
}
}
void LayeredTileMapLayerEditorTilesPlugin::_pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture2D> p_texture) {
void LayeredTileMapLayerEditorTilesPlugin::_pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture> p_texture) {
// TODO optimize ?
for (int i = 0; i < patterns_item_list->get_item_count(); i++) {
if (patterns_item_list->get_item_metadata(i) == p_pattern) {
@ -446,7 +446,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_scenes_collection_view() {
scene_tiles_list->set_fixed_icon_size(Vector2(int_size, int_size));
}
void LayeredTileMapLayerEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, const Variant &p_ud) {
void LayeredTileMapLayerEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, const Variant &p_ud) {
int index = p_ud;
if (index >= 0 && index < scene_tiles_list->get_item_count()) {
@ -549,7 +549,7 @@ bool LayeredTileMapLayerEditorTilesPlugin::forward_canvas_gui_input(const Ref<In
// Fill in the clipboard.
if (!tile_map_selection.is_empty()) {
tile_map_clipboard.instantiate();
TypedArray<Vector2i> coords_array;
PoolVector2iArray coords_array;
for (const Vector2i &E : tile_map_selection) {
coords_array.push_back(E);
}
@ -857,7 +857,7 @@ void LayeredTileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Con
Vector2i offset = drag_start_mouse_pos - tile_set->map_to_local(top_left);
offset = tile_set->local_to_map(mpos - offset) - tile_set->local_to_map(drag_start_mouse_pos - offset);
TypedArray<Vector2i> selection_used_cells = selection_pattern->get_used_cells();
PoolVector2iArray selection_used_cells = selection_pattern->get_used_cells();
for (int i = 0; i < selection_used_cells.size(); i++) {
Vector2i coords = tile_set->map_pattern(offset + top_left, selection_used_cells[i], selection_pattern);
preview[coords] = LayeredTileMapCell(selection_pattern->get_cell_source_id(selection_used_cells[i]), selection_pattern->get_cell_atlas_coords(selection_used_cells[i]), selection_pattern->get_cell_alternative_tile(selection_used_cells[i]));
@ -866,7 +866,7 @@ void LayeredTileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Con
} else if (drag_type == DRAG_TYPE_CLIPBOARD_PASTE) {
// Preview when pasting.
Vector2 mouse_offset = (Vector2(tile_map_clipboard->get_size()) / 2.0 - Vector2(0.5, 0.5)) * tile_set->get_tile_size();
TypedArray<Vector2i> clipboard_used_cells = tile_map_clipboard->get_used_cells();
PoolVector2iArray clipboard_used_cells = tile_map_clipboard->get_used_cells();
for (int i = 0; i < clipboard_used_cells.size(); i++) {
Vector2i coords = tile_set->map_pattern(tile_set->local_to_map(mpos - mouse_offset), clipboard_used_cells[i], tile_map_clipboard);
preview[coords] = LayeredTileMapCell(tile_map_clipboard->get_cell_source_id(clipboard_used_cells[i]), tile_map_clipboard->get_cell_atlas_coords(clipboard_used_cells[i]), tile_map_clipboard->get_cell_alternative_tile(clipboard_used_cells[i]));
@ -1027,7 +1027,7 @@ LayeredTileMapCell LayeredTileMapLayerEditorTilesPlugin::_pick_random_tile(Ref<L
return LayeredTileMapCell();
}
TypedArray<Vector2i> used_cells = p_pattern->get_used_cells();
PoolVector2iArray used_cells = p_pattern->get_used_cells();
double sum = 0.0;
for (int i = 0; i < used_cells.size(); i++) {
int source_id = p_pattern->get_cell_source_id(used_cells[i]);
@ -1102,7 +1102,7 @@ HashMap<Vector2i, LayeredTileMapCell> LayeredTileMapLayerEditorTilesPlugin::_dra
Vector2i new_hovered_cell = tile_set->local_to_map(p_to_mouse_pos - mouse_offset);
Vector2i drag_start_cell = tile_set->local_to_map(p_start_drag_mouse_pos - mouse_offset);
TypedArray<Vector2i> used_cells = pattern->get_used_cells();
PoolVector2iArray used_cells = pattern->get_used_cells();
Vector2i offset = Vector2i(Math::posmod(drag_start_cell.x, pattern->get_size().x), Math::posmod(drag_start_cell.y, pattern->get_size().y)); // Note: no posmodv for Vector2i for now. Meh.s
Vector<Vector2i> line = LayeredTileMapLayerEditor::get_line(edited_layer, (last_hovered_cell - offset) / pattern->get_size(), (new_hovered_cell - offset) / pattern->get_size());
for (int i = 0; i < line.size(); i++) {
@ -1158,7 +1158,7 @@ HashMap<Vector2i, LayeredTileMapCell> LayeredTileMapLayerEditorTilesPlugin::_dra
}
} else {
// Paint the pattern.
TypedArray<Vector2i> used_cells = pattern->get_used_cells();
PoolVector2iArray used_cells = pattern->get_used_cells();
for (int x = 0; x <= rect.size.x / pattern->get_size().x; x++) {
for (int y = 0; y <= rect.size.y / pattern->get_size().y; y++) {
Vector2i pattern_coords = rect.position + Vector2i(x, y) * pattern->get_size() + offset;
@ -1233,7 +1233,7 @@ HashMap<Vector2i, LayeredTileMapCell> LayeredTileMapLayerEditorTilesPlugin::_dra
}
// Get surrounding tiles (handles different tile shapes).
TypedArray<Vector2i> around = tile_set->get_surrounding_cells(coords);
PoolVector2iArray around = tile_set->get_surrounding_cells(coords);
for (int i = 0; i < around.size(); i++) {
to_check.push_back(around[i]);
}
@ -1243,7 +1243,7 @@ HashMap<Vector2i, LayeredTileMapCell> LayeredTileMapLayerEditorTilesPlugin::_dra
}
} else {
// Replace all tiles like the source.
TypedArray<Vector2i> to_check;
PoolVector2iArray to_check;
if (source_cell.source_id == LayeredTileSet::INVALID_SOURCE) {
Rect2i rect = edited_layer->get_used_rect();
if (!rect.has_area()) {
@ -1362,7 +1362,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_stop_dragging() {
Vector2i offset = drag_start_mouse_pos - tile_set->map_to_local(top_left);
offset = tile_set->local_to_map(mpos - offset) - tile_set->local_to_map(drag_start_mouse_pos - offset);
TypedArray<Vector2i> selection_used_cells = selection_pattern->get_used_cells();
PoolVector2iArray selection_used_cells = selection_pattern->get_used_cells();
// Build the list of cells to undo.
Vector2i coords;
@ -1410,7 +1410,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_stop_dragging() {
rect.size += Vector2i(1, 1);
int picked_source = -1;
TypedArray<Vector2i> coords_array;
PoolVector2iArray coords_array;
for (int x = rect.position.x; x < rect.get_end().x; x++) {
for (int y = rect.position.y; y < rect.get_end().y; y++) {
Vector2i coords = Vector2i(x, y);
@ -1488,7 +1488,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_stop_dragging() {
case DRAG_TYPE_CLIPBOARD_PASTE: {
Vector2 mouse_offset = (Vector2(tile_map_clipboard->get_size()) / 2.0 - Vector2(0.5, 0.5)) * tile_set->get_tile_size();
undo_redo->create_action(TTR("Paste tiles"));
TypedArray<Vector2i> used_cells = tile_map_clipboard->get_used_cells();
PoolVector2iArray used_cells = tile_map_clipboard->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) {
Vector2i coords = tile_set->map_pattern(tile_set->local_to_map(mpos - mouse_offset), used_cells[i], tile_map_clipboard);
undo_redo->add_do_method(edited_layer, "set_cell", coords, tile_map_clipboard->get_cell_source_id(used_cells[i]), tile_map_clipboard->get_cell_atlas_coords(used_cells[i]), tile_map_clipboard->get_cell_alternative_tile(used_cells[i]));
@ -1696,7 +1696,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilema
selection_pattern.instantiate();
TypedArray<Vector2i> coords_array;
PoolVector2iArray coords_array;
for (const Vector2i &E : tile_map_selection) {
coords_array.push_back(E);
}
@ -1804,7 +1804,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilese
void LayeredTileMapLayerEditorTilesPlugin::_update_tileset_selection_from_selection_pattern() {
tile_set_selection.clear();
TypedArray<Vector2i> used_cells = selection_pattern->get_used_cells();
PoolVector2iArray used_cells = selection_pattern->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) {
Vector2i coords = used_cells[i];
if (selection_pattern->get_cell_source_id(coords) != LayeredTileSet::INVALID_SOURCE) {
@ -2120,7 +2120,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_tile_alternatives_control_gui_input(
}
}
void LayeredTileMapLayerEditorTilesPlugin::_set_tile_map_selection(const TypedArray<Vector2i> &p_selection) {
void LayeredTileMapLayerEditorTilesPlugin::_set_tile_map_selection(const PoolVector2iArray &p_selection) {
tile_map_selection.clear();
for (int i = 0; i < p_selection.size(); i++) {
tile_map_selection.insert(p_selection[i]);
@ -2130,8 +2130,8 @@ void LayeredTileMapLayerEditorTilesPlugin::_set_tile_map_selection(const TypedAr
CanvasItemEditor::get_singleton()->update_viewport();
}
TypedArray<Vector2i> LayeredTileMapLayerEditorTilesPlugin::_get_tile_map_selection() const {
TypedArray<Vector2i> output;
PoolVector2iArray LayeredTileMapLayerEditorTilesPlugin::_get_tile_map_selection() const {
PoolVector2iArray output;
for (const Vector2i &E : tile_map_selection) {
output.push_back(E);
}
@ -2745,7 +2745,7 @@ RBSet<Vector2i> LayeredTileMapLayerEditorTerrainsPlugin::_get_cells_for_bucket_f
output.insert(coords);
// Get surrounding tiles (handles different tile shapes).
TypedArray<Vector2i> around = tile_set->get_surrounding_cells(coords);
PoolVector2iArray around = tile_set->get_surrounding_cells(coords);
for (int i = 0; i < around.size(); i++) {
to_check.push_back(around[i]);
}
@ -2755,7 +2755,7 @@ RBSet<Vector2i> LayeredTileMapLayerEditorTerrainsPlugin::_get_cells_for_bucket_f
}
} else {
// Replace all tiles like the source.
TypedArray<Vector2i> to_check;
PoolVector2iArray to_check;
if (source_cell.source_id == LayeredTileSet::INVALID_SOURCE) {
Rect2i rect = edited_layer->get_used_rect();
if (!rect.has_area()) {
@ -3349,7 +3349,7 @@ void LayeredTileMapLayerEditorTerrainsPlugin::_update_terrains_tree() {
}
// Fill in the terrain list.
Vector<Vector<Ref<Texture2D>>> icons = tile_set->generate_terrains_icons(Size2(16, 16) * EDSCALE);
Vector<Vector<Ref<Texture>>> icons = tile_set->generate_terrains_icons(Size2(16, 16) * EDSCALE);
for (int terrain_set_index = 0; terrain_set_index < tile_set->get_terrain_sets_count(); terrain_set_index++) {
// Add an item for the terrain set.
TreeItem *terrain_set_tree_item = terrains_tree->create_item();
@ -3437,7 +3437,7 @@ void LayeredTileMapLayerEditorTerrainsPlugin::_update_tiles_list() {
LayeredTileSet::TerrainsPattern terrains_pattern = E;
// Get the icon.
Ref<Texture2D> icon;
Ref<Texture> icon;
Rect2 region;
bool transpose = false;
@ -3695,7 +3695,7 @@ void LayeredTileMapLayerEditor::_advanced_menu_button_id_pressed(int p_id) {
if (p_id == 0) { // Replace Tile Proxies
EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
undo_redo->create_action(TTR("Replace Tiles with Proxies"));
TypedArray<Vector2i> used_cells = edited_layer->get_used_cells();
PoolVector2iArray used_cells = edited_layer->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) {
Vector2i cell_coords = used_cells[i];
LayeredTileMapCell from = edited_layer->get_cell(cell_coords);
@ -3981,7 +3981,7 @@ void LayeredTileMapLayerEditor::forward_canvas_draw_over_viewport(Control *p_ove
Vector2i tile_shape_size = tile_set->get_tile_size();
// Draw tiles with invalid IDs in the grid.
TypedArray<Vector2i> used_cells = edited_layer->get_used_cells();
PoolVector2iArray used_cells = edited_layer->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) {
Vector2i coords = used_cells[i];
int tile_source_id = edited_layer->get_cell_source_id(coords);

34
modules/layered_tile_map/editor/layered_tile_map_layer_editor.h
View File

@ -155,8 +155,8 @@ private:
RBSet<Vector2i> tile_map_selection;
Ref<LayeredTileMapPattern> tile_map_clipboard;
Ref<LayeredTileMapPattern> selection_pattern;
void _set_tile_map_selection(const TypedArray<Vector2i> &p_selection);
TypedArray<Vector2i> _get_tile_map_selection() const;
void _set_tile_map_selection(const PoolVector2iArray &p_selection);
PoolVector2iArray _get_tile_map_selection() const;
RBSet<LayeredTileMapCell> tile_set_selection;
@ -180,7 +180,7 @@ private:
ItemList *sources_list = nullptr;
MenuButton *source_sort_button = nullptr;
Ref<Texture2D> missing_atlas_texture_icon;
Ref<Texture> missing_atlas_texture_icon;
void _update_tile_set_sources_list();
void _update_source_display();
@ -210,7 +210,7 @@ private:
ItemList *scene_tiles_list = nullptr;
void _update_scenes_collection_view();
void _scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, const Variant &p_ud);
void _scene_thumbnail_done(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, const Variant &p_ud);
void _scenes_list_multi_selected(int p_index, bool p_selected);
void _scenes_list_lmb_empty_clicked(const Vector2 &p_pos, MouseButton p_mouse_button_index);
@ -219,7 +219,7 @@ private:
ItemList *patterns_item_list = nullptr;
Label *patterns_help_label = nullptr;
void _patterns_item_list_gui_input(const Ref<InputEvent> &p_event);
void _pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture2D> p_texture);
void _pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture> p_texture);
bool select_last_pattern = false;
void _update_patterns_list();
@ -228,17 +228,17 @@ private:
List<BaseButton *> viewport_shortcut_buttons;
// Update callback
virtual void tile_set_changed() override;
virtual void tile_set_changed();
protected:
static void _bind_methods();
public:
virtual Vector<TabData> get_tabs() const override;
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override;
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override;
virtual Vector<TabData> get_tabs() const;
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event);
virtual void forward_canvas_draw_over_viewport(Control *p_overlay);
virtual void edit(ObjectID p_tile_map_layer_id) override;
virtual void edit(ObjectID p_tile_map_layer_id);
LayeredTileMapLayerEditorTilesPlugin();
~LayeredTileMapLayerEditorTilesPlugin();
@ -323,14 +323,14 @@ private:
void _update_theme();
// Update callback
virtual void tile_set_changed() override;
virtual void tile_set_changed();
public:
virtual Vector<TabData> get_tabs() const override;
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override;
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override;
virtual Vector<TabData> get_tabs() const;
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event);
virtual void forward_canvas_draw_over_viewport(Control *p_overlay);
virtual void edit(ObjectID p_tile_map_layer_id) override;
virtual void edit(ObjectID p_tile_map_layer_id);
LayeredTileMapLayerEditorTerrainsPlugin();
~LayeredTileMapLayerEditorTerrainsPlugin();
@ -371,8 +371,8 @@ private:
void _update_bottom_panel();
// LayeredTileMap.
Ref<Texture2D> missing_tile_texture;
Ref<Texture2D> warning_pattern_texture;
Ref<Texture> missing_tile_texture;
Ref<Texture> warning_pattern_texture;
// CallBack.
void _tile_map_layer_changed();

2
modules/layered_tile_map/editor/layered_tile_proxies_manager_dialog.h
View File

@ -78,7 +78,7 @@ protected:
bool _set(const StringName &p_name, const Variant &p_value);
bool _get(const StringName &p_name, Variant &r_ret) const;
void _unhandled_key_input(Ref<InputEvent> p_event);
virtual void cancel_pressed() override;
virtual void cancel_pressed();
static void _bind_methods();
public:

10
modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.cpp
View File

@ -914,7 +914,7 @@ void LayeredTileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw() {
}
RID ci = tile_data_editor_dropdown_button->get_canvas_item();
Ref<Texture2D> arrow = Control::get_theme_icon(SNAME("arrow"), SNAME("OptionButton"));
Ref<Texture> arrow = Control::get_theme_icon(SNAME("arrow"), SNAME("OptionButton"));
Color clr = Color(1, 1, 1);
if (get_theme_constant(SNAME("modulate_arrow"))) {
switch (tile_data_editor_dropdown_button->get_draw_mode()) {
@ -2184,7 +2184,7 @@ void LayeredTileSetAtlasSourceEditor::edit(Ref<LayeredTileSet> p_tile_set, Layer
tile_set_atlas_source->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_source_texture));
if (atlas_source_texture.is_valid()) {
atlas_source_texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
atlas_source_texture = Ref<Texture2D>();
atlas_source_texture = Ref<Texture>();
}
}
@ -2244,7 +2244,7 @@ void LayeredTileSetAtlasSourceEditor::_update_source_texture() {
if (atlas_source_texture.is_valid()) {
atlas_source_texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
atlas_source_texture = Ref<Texture2D>();
atlas_source_texture = Ref<Texture>();
}
if (!tile_set_atlas_source || tile_set_atlas_source->get_texture().is_null()) {
@ -2295,7 +2295,7 @@ void LayeredTileSetAtlasSourceEditor::_cleanup_outside_tiles() {
void LayeredTileSetAtlasSourceEditor::_auto_create_tiles() {
for (Ref<LayeredTileSetAtlasSource> &atlas_source : atlases_to_auto_create_tiles) {
if (atlas_source.is_valid()) {
Ref<Texture2D> texture = atlas_source->get_texture();
Ref<Texture> texture = atlas_source->get_texture();
if (texture.is_valid()) {
Vector2i margins = atlas_source->get_margins();
Vector2i separation = atlas_source->get_separation();
@ -2348,7 +2348,7 @@ void LayeredTileSetAtlasSourceEditor::_auto_remove_tiles() {
return;
}
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
Ref<Texture> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins();
Vector2i separation = tile_set_atlas_source->get_separation();

16
modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.h
View File

@ -117,7 +117,7 @@ public:
LayeredTileSetAtlasSourceEditor *editor = nullptr;
public:
virtual CursorShape get_cursor_shape(const Point2 &p_pos) const override;
virtual CursorShape get_cursor_shape(const Point2 &p_pos) const;
LayeredTileAtlasControl(LayeredTileSetAtlasSourceEditor *p_editor) { editor = p_editor; }
};
friend class LayeredTileAtlasControl;
@ -128,7 +128,7 @@ private:
Ref<LayeredTileSet> tile_set;
LayeredTileSetAtlasSource *tile_set_atlas_source = nullptr;
int tile_set_atlas_source_id = LayeredTileSet::INVALID_SOURCE;
Ref<Texture2D> atlas_source_texture;
Ref<Texture> atlas_source_texture;
bool tile_set_changed_needs_update = false;
@ -238,8 +238,8 @@ private:
PopupMenu *base_tile_popup_menu = nullptr;
PopupMenu *empty_base_tile_popup_menu = nullptr;
Ref<Texture2D> resize_handle;
Ref<Texture2D> resize_handle_disabled;
Ref<Texture> resize_handle;
Ref<Texture> resize_handle_disabled;
Control *tile_atlas_control = nullptr;
Control *tile_atlas_control_unscaled = nullptr;
void _tile_atlas_control_draw();
@ -294,7 +294,7 @@ protected:
static void _bind_methods();
// -- input events --
virtual void shortcut_input(const Ref<InputEvent> &p_event) override;
virtual void shortcut_input(const Ref<InputEvent> &p_event);
public:
void edit(Ref<LayeredTileSet> p_tile_set, LayeredTileSetAtlasSource *p_tile_set_source, int p_source_id);
@ -317,7 +317,7 @@ class EditorPropertyTilePolygon : public EditorProperty {
void _polygons_changed();
public:
virtual void update_property() override;
virtual void update_property();
void setup_single_mode(const StringName &p_property, const String &p_base_type);
void setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type);
EditorPropertyTilePolygon();
@ -330,8 +330,8 @@ class EditorInspectorPluginTileData : public EditorInspectorPlugin {
void _polygons_changed(Object *p_generic_tile_polygon_editor, Object *p_object, const String &p_path);
public:
virtual bool can_handle(Object *p_object) override;
virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false) override;
virtual bool can_handle(Object *p_object);
virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false);
};
#endif // TILE_SET_ATLAS_SOURCE_EDITOR_H

6
modules/layered_tile_map/editor/layered_tile_set_editor.cpp
View File

@ -105,7 +105,7 @@ void LayeredTileSetEditor::_load_texture_files(const Vector<String> &p_paths) {
Vector<Ref<LayeredTileSetAtlasSource>> atlases;
for (const String &p_path : p_paths) {
Ref<Texture2D> texture = ResourceLoader::load(p_path);
Ref<Texture> texture = ResourceLoader::load(p_path);
if (texture.is_null()) {
EditorNode::get_singleton()->show_warning(TTR("Invalid texture selected."));
@ -166,7 +166,7 @@ void LayeredTileSetEditor::_update_sources_list(int force_selected_id) {
for (const int &source_id : source_ids) {
LayeredTileSetSource *source = *tile_set->get_source(source_id);
Ref<Texture2D> texture;
Ref<Texture> texture;
String item_text;
// Common to all type of sources.
@ -424,7 +424,7 @@ void LayeredTileSetEditor::_patterns_item_list_gui_input(const Ref<InputEvent> &
}
}
void LayeredTileSetEditor::_pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture2D> p_texture) {
void LayeredTileSetEditor::_pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture> p_texture) {
// TODO optimize ?
for (int i = 0; i < patterns_item_list->get_item_count(); i++) {
if (patterns_item_list->get_item_metadata(i) == p_pattern) {

8
modules/layered_tile_map/editor/layered_tile_set_editor.h
View File

@ -79,7 +79,7 @@ private:
MenuButton *source_sort_button = nullptr;
MenuButton *sources_advanced_menu_button = nullptr;
ItemList *sources_list = nullptr;
Ref<Texture2D> missing_texture_texture;
Ref<Texture> missing_texture_texture;
void _source_selected(int p_source_index);
void _source_delete_pressed();
void _source_add_id_pressed(int p_id_pressed);
@ -96,7 +96,7 @@ private:
ItemList *patterns_item_list = nullptr;
Label *patterns_help_label = nullptr;
void _patterns_item_list_gui_input(const Ref<InputEvent> &p_event);
void _pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture2D> p_texture);
void _pattern_preview_done(Ref<LayeredTileMapPattern> p_pattern, Ref<Texture> p_texture);
bool select_last_pattern = false;
void _update_patterns_list();
@ -139,8 +139,8 @@ class LayeredTileSourceInspectorPlugin : public EditorInspectorPlugin {
void _confirm_change_id();
public:
virtual bool can_handle(Object *p_object) override;
virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false) override;
virtual bool can_handle(Object *p_object);
virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide = false);
};
#endif // TILE_SET_EDITOR_H

2
modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.cpp
View File

@ -225,7 +225,7 @@ void LayeredTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_sou
tile_set_scenes_collection_source_changed_needs_update = true;
}
void LayeredTileSetScenesCollectionSourceEditor::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, const Variant &p_ud) {
void LayeredTileSetScenesCollectionSourceEditor::_scene_thumbnail_done(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, const Variant &p_ud) {
int index = p_ud;
if (index >= 0 && index < scene_tiles_list->get_item_count()) {

2
modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.h
View File

@ -120,7 +120,7 @@ private:
void _tile_set_scenes_collection_source_changed();
void _scenes_collection_source_proxy_object_changed(const String &p_what);
void _scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, const Variant &p_ud);
void _scene_thumbnail_done(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, const Variant &p_ud);
void _scenes_list_item_activated(int p_index);
void _source_add_pressed();

8
modules/layered_tile_map/editor/layered_tiles_editor_plugin.cpp
View File

@ -99,7 +99,7 @@ void LayeredTilesEditorUtils::_thread() {
tile_map->set_pattern(0, Vector2(), item.pattern);
viewport->add_child(tile_map);
TypedArray<Vector2i> used_cells = tile_map->get_used_cells(0);
PoolVector2iArray used_cells = tile_map->get_used_cells(0);
Rect2 encompassing_rect;
encompassing_rect.set_position(tile_map->map_to_local(used_cells[0]));
@ -248,7 +248,7 @@ bool LayeredTilesEditorUtils::SourceNameComparator::operator()(const int &p_a, c
LayeredTileSetAtlasSource *atlas_source = Object::cast_to<LayeredTileSetAtlasSource>(source);
if (atlas_source) {
Ref<Texture2D> texture = atlas_source->get_texture();
Ref<Texture> texture = atlas_source->get_texture();
if (name_a.is_empty() && texture.is_valid()) {
name_a = texture->get_path().get_file();
}
@ -268,7 +268,7 @@ bool LayeredTilesEditorUtils::SourceNameComparator::operator()(const int &p_a, c
LayeredTileSetAtlasSource *atlas_source = Object::cast_to<LayeredTileSetAtlasSource>(source);
if (atlas_source) {
Ref<Texture2D> texture = atlas_source->get_texture();
Ref<Texture> texture = atlas_source->get_texture();
if (name_b.is_empty() && texture.is_valid()) {
name_b = texture->get_path().get_file();
}
@ -288,7 +288,7 @@ void LayeredTilesEditorUtils::display_tile_set_editor_panel() {
}
void LayeredTilesEditorUtils::draw_selection_rect(CanvasItem *p_ci, const Rect2 &p_rect, const Color &p_color) {
Ref<Texture2D> selection_texture = EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("TileSelection"), EditorStringName(EditorIcons));
Ref<Texture> selection_texture = EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("TileSelection"), EditorStringName(EditorIcons));
real_t scale = p_ci->get_global_transform().get_scale().x * 0.5;
p_ci->draw_set_transform(p_rect.position, 0, Vector2(1, 1) / scale);

16
modules/layered_tile_map/editor/layered_tiles_editor_plugin.h
View File

@ -134,12 +134,12 @@ protected:
void _notification(int p_notification);
public:
virtual void edit(Object *p_object) override;
virtual bool handles(Object *p_object) const override;
virtual void make_visible(bool p_visible) override;
virtual void edit(Object *p_object);
virtual bool handles(Object *p_object) const;
virtual void make_visible(bool p_visible);
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override;
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override;
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event);
virtual void forward_canvas_draw_over_viewport(Control *p_overlay);
void hide_editor();
bool is_editor_visible() const;
@ -157,9 +157,9 @@ class LayeredTileSetEditorPlugin : public EditorPlugin {
ObjectID edited_tileset;
public:
virtual void edit(Object *p_object) override;
virtual bool handles(Object *p_object) const override;
virtual void make_visible(bool p_visible) override;
virtual void edit(Object *p_object);
virtual bool handles(Object *p_object) const;
virtual void make_visible(bool p_visible);
ObjectID get_edited_tileset() const;

2
modules/layered_tile_map/geometry_parser/layered_tilemap_navigation_geometry_parser_2d.cpp
View File

@ -132,7 +132,7 @@ void LayeredTileMap2DNavigationGeometryParser2D::parse_geometry(Node *p_node, Re
}
const Transform2D tilemap_xform = tilemap->get_transform();
TypedArray<Vector2i> used_cells = tilemap->get_used_cells(tilemap_layer);
PoolVector2iArray used_cells = tilemap->get_used_cells(tilemap_layer);
for (int used_cell_index = 0; used_cell_index < used_cells.size(); used_cell_index++) {
const Vector2i &cell = used_cells[used_cell_index];

20
modules/layered_tile_map/layered_tile_map.cpp
View File

@ -129,7 +129,7 @@ void LayeredTileMap::draw_tile(RID p_canvas_item, const Vector2 &p_position, con
}
// Get the texture.
Ref<Texture2D> tex = atlas_source->get_runtime_texture();
Ref<Texture> tex = atlas_source->get_runtime_texture();
if (!tex.is_valid()) {
return;
}
@ -410,7 +410,7 @@ TileData *LayeredTileMap::get_cell_tile_data(int p_layer, const Vector2i &p_coor
TILEMAP_CALL_FOR_LAYER_V(p_layer, nullptr, get_cell_tile_data, p_coords, p_use_proxies);
}
Ref<LayeredTileMapPattern> LayeredTileMap::get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array) {
Ref<LayeredTileMapPattern> LayeredTileMap::get_pattern(int p_layer, PoolVector2iArray p_coords_array) {
TILEMAP_CALL_FOR_LAYER_V(p_layer, Ref<LayeredTileMapPattern>(), get_pattern, p_coords_array);
}
@ -443,11 +443,11 @@ HashMap<Vector2i, LayeredTileSet::TerrainsPattern> LayeredTileMap::terrain_fill_
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);
}
void LayeredTileMap::set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
void LayeredTileMap::set_cells_terrain_connect(int p_layer, PoolVector2iArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
TILEMAP_CALL_FOR_LAYER(p_layer, set_cells_terrain_connect, p_cells, p_terrain_set, p_terrain, p_ignore_empty_terrains);
}
void LayeredTileMap::set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
void LayeredTileMap::set_cells_terrain_path(int p_layer, PoolVector2iArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
TILEMAP_CALL_FOR_LAYER(p_layer, set_cells_terrain_path, p_path, p_terrain_set, p_terrain, p_ignore_empty_terrains);
}
@ -763,12 +763,12 @@ Vector2i LayeredTileMap::get_neighbor_cell(const Vector2i &p_coords, LayeredTile
return tile_set->get_neighbor_cell(p_coords, p_cell_neighbor);
}
TypedArray<Vector2i> LayeredTileMap::get_used_cells(int p_layer) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, TypedArray<Vector2i>(), get_used_cells);
PoolVector2iArray LayeredTileMap::get_used_cells(int p_layer) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, PoolVector2iArray(), get_used_cells);
}
TypedArray<Vector2i> 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, TypedArray<Vector2i>(), get_used_cells_by_id, p_source_id, p_atlas_coords, p_alternative_tile);
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);
}
Rect2i LayeredTileMap::get_used_rect() const {
@ -824,9 +824,9 @@ void LayeredTileMap::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repe
}
}
TypedArray<Vector2i> LayeredTileMap::get_surrounding_cells(const Vector2i &p_coords) {
PoolVector2iArray LayeredTileMap::get_surrounding_cells(const Vector2i &p_coords) {
if (!tile_set.is_valid()) {
return TypedArray<Vector2i>();
return PoolVector2iArray();
}
return tile_set->get_surrounding_cells(p_coords);

26
modules/layered_tile_map/layered_tile_map.h
View File

@ -103,7 +103,7 @@ protected:
public:
#ifdef TOOLS_ENABLED
virtual Rect2 _edit_get_rect() const override;
virtual Rect2 _edit_get_rect() const;
#endif
#ifndef DISABLE_DEPRECATED
@ -158,7 +158,7 @@ public:
TileData *get_cell_tile_data(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
// Patterns.
Ref<LayeredTileMapPattern> get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array);
Ref<LayeredTileMapPattern> get_pattern(int p_layer, PoolVector2iArray p_coords_array);
Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<LayeredTileMapPattern> p_pattern);
void set_pattern(int p_layer, const Vector2i &p_position, const Ref<LayeredTileMapPattern> p_pattern);
@ -169,29 +169,29 @@ public:
HashMap<Vector2i, LayeredTileSet::TerrainsPattern> 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 = true);
// Terrains (exposed).
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);
void set_cells_terrain_connect(int p_layer, PoolVector2iArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
void set_cells_terrain_path(int p_layer, PoolVector2iArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
// Not exposed to users.
LayeredTileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
int get_effective_quadrant_size(int p_layer) const;
virtual void set_y_sort_enabled(bool p_enable) override;
virtual void set_y_sort_enabled(bool p_enable);
Vector2 map_to_local(const Vector2i &p_pos) const;
Vector2i local_to_map(const Vector2 &p_pos) const;
bool is_existing_neighbor(LayeredTileSet::CellNeighbor p_cell_neighbor) const;
Vector2i get_neighbor_cell(const Vector2i &p_coords, LayeredTileSet::CellNeighbor p_cell_neighbor) const;
TypedArray<Vector2i> get_used_cells(int p_layer) const;
TypedArray<Vector2i> get_used_cells_by_id(int p_layer, int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) const;
PoolVector2iArray get_used_cells(int p_layer) const;
PoolVector2iArray get_used_cells_by_id(int p_layer, int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) const;
Rect2i get_used_rect() const;
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems.
virtual void set_light_mask(int p_light_mask) override;
virtual void set_self_modulate(const Color &p_self_modulate) override;
virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override;
virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override;
virtual void set_light_mask(int p_light_mask);
virtual void set_self_modulate(const Color &p_self_modulate);
virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter);
virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat);
// For finding tiles from collision.
Vector2i get_coords_for_body_rid(RID p_physics_body);
@ -210,14 +210,14 @@ public:
void notify_runtime_tile_data_update(int p_layer = -1);
// Helpers?
TypedArray<Vector2i> get_surrounding_cells(const Vector2i &p_coords);
PoolVector2iArray get_surrounding_cells(const Vector2i &p_coords);
// 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 *);
// Configuration warnings.
PackedStringArray get_configuration_warnings() const override;
PackedStringArray get_configuration_warnings() const;
LayeredTileMap();
~LayeredTileMap();

16
modules/layered_tile_map/layered_tile_map_layer.cpp
View File

@ -2341,7 +2341,7 @@ void LayeredTileMapLayer::clear() {
used_rect_cache_dirty = true;
}
Ref<LayeredTileMapPattern> LayeredTileMapLayer::get_pattern(TypedArray<Vector2i> p_coords_array) {
Ref<LayeredTileMapPattern> LayeredTileMapLayer::get_pattern(PoolVector2iArray p_coords_array) {
const Ref<LayeredTileSet> &tile_set = get_effective_tile_set();
ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
@ -2400,14 +2400,14 @@ void LayeredTileMapLayer::set_pattern(const Vector2i &p_position, const Ref<Laye
ERR_FAIL_COND(tile_set.is_null());
ERR_FAIL_COND(p_pattern.is_null());
TypedArray<Vector2i> used_cells = p_pattern->get_used_cells();
PoolVector2iArray used_cells = p_pattern->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) {
Vector2i coords = tile_set->map_pattern(p_position, used_cells[i], p_pattern);
set_cell(coords, p_pattern->get_cell_source_id(used_cells[i]), p_pattern->get_cell_atlas_coords(used_cells[i]), p_pattern->get_cell_alternative_tile(used_cells[i]));
}
}
void LayeredTileMapLayer::set_cells_terrain_connect(TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
void LayeredTileMapLayer::set_cells_terrain_connect(PoolVector2iArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
const Ref<LayeredTileSet> &tile_set = get_effective_tile_set();
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count());
@ -2447,7 +2447,7 @@ void LayeredTileMapLayer::set_cells_terrain_connect(TypedArray<Vector2i> p_cells
}
}
void LayeredTileMapLayer::set_cells_terrain_path(TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
void LayeredTileMapLayer::set_cells_terrain_path(PoolVector2iArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
const Ref<LayeredTileSet> &tile_set = get_effective_tile_set();
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count());
@ -2488,9 +2488,9 @@ void LayeredTileMapLayer::set_cells_terrain_path(TypedArray<Vector2i> p_path, in
}
}
TypedArray<Vector2i> LayeredTileMapLayer::get_used_cells() const {
PoolVector2iArray LayeredTileMapLayer::get_used_cells() const {
// Returns the cells used in the tilemap.
TypedArray<Vector2i> a;
PoolVector2iArray a;
for (const KeyValue<Vector2i, CellData> &E : tile_map) {
const LayeredTileMapCell &c = E.value.cell;
if (c.source_id == LayeredTileSet::INVALID_SOURCE) {
@ -2502,9 +2502,9 @@ TypedArray<Vector2i> LayeredTileMapLayer::get_used_cells() const {
return a;
}
TypedArray<Vector2i> LayeredTileMapLayer::get_used_cells_by_id(int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) const {
PoolVector2iArray LayeredTileMapLayer::get_used_cells_by_id(int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) const {
// Returns the cells used in the tilemap.
TypedArray<Vector2i> a;
PoolVector2iArray a;
for (const KeyValue<Vector2i, CellData> &E : tile_map) {
const LayeredTileMapCell &c = E.value.cell;
if (c.source_id == LayeredTileSet::INVALID_SOURCE) {

22
modules/layered_tile_map/layered_tile_map_layer.h
View File

@ -397,29 +397,29 @@ public:
void clear();
// Patterns.
Ref<LayeredTileMapPattern> get_pattern(TypedArray<Vector2i> p_coords_array);
Ref<LayeredTileMapPattern> get_pattern(PoolVector2iArray p_coords_array);
void set_pattern(const Vector2i &p_position, const Ref<LayeredTileMapPattern> 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);
void set_cells_terrain_connect(PoolVector2iArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
void set_cells_terrain_path(PoolVector2iArray 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 = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) const;
PoolVector2iArray get_used_cells() const;
PoolVector2iArray get_used_cells_by_id(int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) const;
Rect2i get_used_rect() const;
// Layer properties.
void set_enabled(bool p_enabled);
bool is_enabled() const;
virtual void set_self_modulate(const Color &p_self_modulate) override;
virtual void set_y_sort_enabled(bool p_y_sort_enabled) override;
virtual void set_self_modulate(const Color &p_self_modulate);
virtual void set_y_sort_enabled(bool p_y_sort_enabled);
void set_y_sort_origin(int p_y_sort_origin);
int get_y_sort_origin() const;
virtual void set_z_index(int p_z_index) override;
virtual void set_light_mask(int p_light_mask) override;
virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override;
virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override;
virtual void set_z_index(int p_z_index);
virtual void set_light_mask(int p_light_mask);
virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter);
virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat);
void set_rendering_quadrant_size(int p_size);
int get_rendering_quadrant_size() const;

2
modules/layered_tile_map/layered_tile_map_layer_group.h
View File

@ -51,7 +51,7 @@ private:
protected:
Ref<LayeredTileSet> tile_set;
virtual void remove_child_notify(Node *p_child) override;
virtual void remove_child_notify(Node *p_child);
static void _bind_methods();

40
modules/layered_tile_map/layered_tile_set.cpp
View File

@ -144,9 +144,9 @@ int LayeredTileMapPattern::get_cell_alternative_tile(const Vector2i &p_coords) c
return pattern[p_coords].alternative_tile;
}
TypedArray<Vector2i> LayeredTileMapPattern::get_used_cells() const {
PoolVector2iArray LayeredTileMapPattern::get_used_cells() const {
// Returns the cells used in the tilemap.
TypedArray<Vector2i> a;
PoolVector2iArray a;
a.resize(pattern.size());
int i = 0;
for (const KeyValue<Vector2i, LayeredTileMapCell> &E : pattern) {
@ -1519,7 +1519,7 @@ Vector<Vector2> LayeredTileSet::get_tile_shape_polygon() const {
return points;
}
void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled, Ref<Texture2D> p_texture) const {
void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled, Ref<Texture> p_texture) const {
if (tile_meshes_dirty) {
Vector<Vector2> shape = get_tile_shape_polygon();
Vector<Vector2> uvs;
@ -1559,7 +1559,7 @@ void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_tr
if (p_filled) {
p_canvas_item->draw_mesh(tile_filled_mesh, p_texture, p_transform, p_color);
} else {
p_canvas_item->draw_mesh(tile_lines_mesh, Ref<Texture2D>(), p_transform, p_color);
p_canvas_item->draw_mesh(tile_lines_mesh, Ref<Texture>(), p_transform, p_color);
}
}
@ -2165,8 +2165,8 @@ Vector2i LayeredTileSet::get_neighbor_cell(const Vector2i &p_coords, LayeredTile
}
}
TypedArray<Vector2i> LayeredTileSet::get_surrounding_cells(const Vector2i &p_coords) const {
TypedArray<Vector2i> around;
PoolVector2iArray LayeredTileSet::get_surrounding_cells(const Vector2i &p_coords) const {
PoolVector2iArray around;
if (tile_shape == LayeredTileSet::TILE_SHAPE_SQUARE) {
around.push_back(get_neighbor_cell(p_coords, LayeredTileSet::CELL_NEIGHBOR_RIGHT_SIDE));
around.push_back(get_neighbor_cell(p_coords, LayeredTileSet::CELL_NEIGHBOR_BOTTOM_SIDE));
@ -2453,7 +2453,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
if (terrain_id >= 0) {
Color color = get_terrain_color(terrain_set, terrain_id);
color.a = TERRAIN_ALPHA;
p_canvas_item->draw_mesh(terrain_meshes[terrain_mode], Ref<Texture2D>(), Transform2D(), color);
p_canvas_item->draw_mesh(terrain_meshes[terrain_mode], Ref<Texture>(), Transform2D(), color);
}
for (int i = 0; i < LayeredTileSet::CELL_NEIGHBOR_MAX; i++) {
@ -2463,22 +2463,22 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
if (terrain_id >= 0) {
Color color = get_terrain_color(terrain_set, terrain_id);
color.a = TERRAIN_ALPHA;
p_canvas_item->draw_mesh(terrain_peering_bits_meshes[terrain_mode][bit], Ref<Texture2D>(), Transform2D(), color);
p_canvas_item->draw_mesh(terrain_peering_bits_meshes[terrain_mode][bit], Ref<Texture>(), Transform2D(), color);
}
}
}
RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), Transform2D());
}
Vector<Vector<Ref<Texture2D>>> LayeredTileSet::generate_terrains_icons(Size2i p_size) {
Vector<Vector<Ref<Texture>>> LayeredTileSet::generate_terrains_icons(Size2i p_size) {
// Counts the number of matching terrain tiles and find the best matching icon.
struct Count {
int count = 0;
float probability = 0.0;
Ref<Texture2D> texture;
Ref<Texture> texture;
Rect2i region;
};
Vector<Vector<Ref<Texture2D>>> output;
Vector<Vector<Ref<Texture>>> output;
LocalVector<LocalVector<Count>> counts;
output.resize(get_terrain_sets_count());
counts.resize(get_terrain_sets_count());
@ -2501,7 +2501,7 @@ Vector<Vector<Ref<Texture2D>>> LayeredTileSet::generate_terrains_icons(Size2i p_
TileData *tile_data = atlas_source->get_tile_data(tile_id, alternative_id);
int terrain_set = tile_data->get_terrain_set();
if (terrain_set >= 0) {
ERR_FAIL_INDEX_V(terrain_set, get_terrain_sets_count(), Vector<Vector<Ref<Texture2D>>>());
ERR_FAIL_INDEX_V(terrain_set, get_terrain_sets_count(), Vector<Vector<Ref<Texture>>>());
LocalVector<int> bit_counts;
bit_counts.resize(get_terrains_count(terrain_set));
@ -2546,7 +2546,7 @@ Vector<Vector<Ref<Texture2D>>> LayeredTileSet::generate_terrains_icons(Size2i p_
dst_image.instantiate();
if (counts[terrain_set][terrain].count > 0) {
// Get the best tile.
Ref<Texture2D> src_texture = counts[terrain_set][terrain].texture;
Ref<Texture> src_texture = counts[terrain_set][terrain].texture;
ERR_FAIL_COND_V(src_texture.is_null(), output);
Ref<Image> src_image = src_texture->get_image();
ERR_FAIL_COND_V(src_image.is_null(), output);
@ -4629,7 +4629,7 @@ void LayeredTileSetAtlasSource::reset_state() {
_queue_update_padded_texture();
}
void LayeredTileSetAtlasSource::set_texture(Ref<Texture2D> p_texture) {
void LayeredTileSetAtlasSource::set_texture(Ref<Texture> p_texture) {
if (texture.is_valid()) {
texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
}
@ -4644,7 +4644,7 @@ void LayeredTileSetAtlasSource::set_texture(Ref<Texture2D> p_texture) {
emit_changed();
}
Ref<Texture2D> LayeredTileSetAtlasSource::get_texture() const {
Ref<Texture> LayeredTileSetAtlasSource::get_texture() const {
return texture;
}
@ -4710,7 +4710,7 @@ bool LayeredTileSetAtlasSource::get_use_texture_padding() const {
}
Vector2i LayeredTileSetAtlasSource::get_atlas_grid_size() const {
Ref<Texture2D> txt = get_texture();
Ref<Texture> txt = get_texture();
if (!txt.is_valid()) {
return Vector2i();
}
@ -5228,7 +5228,7 @@ void LayeredTileSetAtlasSource::clear_tiles_outside_texture() {
}
}
PackedVector2Array LayeredTileSetAtlasSource::get_tiles_to_be_removed_on_change(Ref<Texture2D> p_texture, Vector2i p_margins, Vector2i p_separation, Vector2i p_texture_region_size) {
PackedVector2Array LayeredTileSetAtlasSource::get_tiles_to_be_removed_on_change(Ref<Texture> p_texture, Vector2i p_margins, Vector2i p_separation, Vector2i p_texture_region_size) {
ERR_FAIL_COND_V(p_margins.x < 0 || p_margins.y < 0, PackedVector2Array());
ERR_FAIL_COND_V(p_separation.x < 0 || p_separation.y < 0, PackedVector2Array());
ERR_FAIL_COND_V(p_texture_region_size.x <= 0 || p_texture_region_size.y <= 0, PackedVector2Array());
@ -5286,7 +5286,7 @@ int LayeredTileSetAtlasSource::alternative_no_transform(int p_alternative_id) {
}
// Getters for texture and tile region (padded or not)
Ref<Texture2D> LayeredTileSetAtlasSource::get_runtime_texture() const {
Ref<Texture> LayeredTileSetAtlasSource::get_runtime_texture() const {
if (use_texture_padding) {
return padded_texture;
} else {
@ -5574,7 +5574,7 @@ void LayeredTileSetAtlasSource::_queue_update_padded_texture() {
callable_mp(this, &LayeredTileSetAtlasSource::_update_padded_texture).call_deferred();
}
Ref<ImageTexture> LayeredTileSetAtlasSource::_create_padded_image_texture(const Ref<Texture2D> &p_source) {
Ref<ImageTexture> LayeredTileSetAtlasSource::_create_padded_image_texture(const Ref<Texture> &p_source) {
ERR_FAIL_COND_V(p_source.is_null(), Ref<ImageTexture>());
Ref<Image> src_image = p_source->get_image();
@ -5646,7 +5646,7 @@ void LayeredTileSetAtlasSource::_update_padded_texture() {
if (src_canvas_texture.is_valid()) {
// Use all textures.
// Diffuse
Ref<Texture2D> src = src_canvas_texture->get_diffuse_texture();
Ref<Texture> src = src_canvas_texture->get_diffuse_texture();
Ref<ImageTexture> image_texture;
if (src.is_valid()) {
padded_texture->set_diffuse_texture(_create_padded_image_texture(src));

92
modules/layered_tile_map/layered_tile_set.h
View File

@ -140,7 +140,7 @@ public:
int get_cell_alternative_tile(const Vector2i &p_coords) const;
const HashMap<Vector2i, LayeredTileMapCell> &get_pattern() const { return pattern; }
TypedArray<Vector2i> get_used_cells() const;
PoolVector2iArray get_used_cells() const;
Size2i get_size() const;
void set_size(const Size2i &p_size);
@ -164,7 +164,7 @@ private:
struct CompatibilityTileData {
String name;
Ref<Texture2D> texture;
Ref<Texture> texture;
Vector2 tex_offset;
Ref<Material> material;
Rect2 region;
@ -530,24 +530,24 @@ public:
// Helpers
Vector<Vector2> get_tile_shape_polygon() const;
void draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled = false, Ref<Texture2D> p_texture = Ref<Texture2D>()) const;
void draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled = false, Ref<Texture> p_texture = Ref<Texture>()) const;
// Used by LayeredTileMap/LayeredTileMapLayer
Vector2 map_to_local(const Vector2i &p_pos) const;
Vector2i local_to_map(const Vector2 &p_pos) const;
bool is_existing_neighbor(LayeredTileSet::CellNeighbor p_cell_neighbor) const;
Vector2i get_neighbor_cell(const Vector2i &p_coords, LayeredTileSet::CellNeighbor p_cell_neighbor) const;
TypedArray<Vector2i> get_surrounding_cells(const Vector2i &p_coords) const;
PoolVector2iArray get_surrounding_cells(const Vector2i &p_coords) const;
Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<LayeredTileMapPattern> p_pattern) const;
void draw_cells_outline(CanvasItem *p_canvas_item, const RBSet<Vector2i> &p_cells, Color p_color, Transform2D p_transform = Transform2D()) const;
Vector<Point2> get_terrain_polygon(int p_terrain_set);
Vector<Point2> get_terrain_peering_bit_polygon(int p_terrain_set, LayeredTileSet::CellNeighbor p_bit);
void draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, const TileData *p_tile_data);
Vector<Vector<Ref<Texture2D>>> generate_terrains_icons(Size2i p_size);
Vector<Vector<Ref<Texture>>> generate_terrains_icons(Size2i p_size);
// Resource management
virtual void reset_state() override;
virtual void reset_state();
// Helpers.
static Vector2i transform_coords_layout(const Vector2i &p_coords, LayeredTileSet::TileOffsetAxis p_offset_axis, LayeredTileSet::TileLayout p_from_layout, LayeredTileSet::TileLayout p_to_layout);
@ -590,7 +590,7 @@ public:
virtual void add_custom_data_layer(int p_index){};
virtual void move_custom_data_layer(int p_from_index, int p_to_pos){};
virtual void remove_custom_data_layer(int p_index){};
virtual void reset_state() override;
virtual void reset_state();
// Tiles.
virtual int get_tiles_count() const = 0;
@ -637,7 +637,7 @@ private:
int next_alternative_id = 1;
};
Ref<Texture2D> texture;
Ref<Texture> texture;
Vector2i margins;
Vector2i separation;
Size2i texture_region_size = Size2i(16, 16);
@ -658,7 +658,7 @@ private:
Ref<CanvasTexture> padded_texture;
bool padded_texture_needs_update = false;
void _queue_update_padded_texture();
Ref<ImageTexture> _create_padded_image_texture(const Ref<Texture2D> &p_source);
Ref<ImageTexture> _create_padded_image_texture(const Ref<Texture> &p_source);
void _update_padded_texture();
protected:
@ -670,32 +670,32 @@ protected:
public:
// Not exposed.
virtual void set_tile_set(const LayeredTileSet *p_tile_set) override;
virtual void set_tile_set(const LayeredTileSet *p_tile_set);
const LayeredTileSet *get_tile_set() const;
virtual void notify_tile_data_properties_should_change() override;
virtual void add_occlusion_layer(int p_index) override;
virtual void move_occlusion_layer(int p_from_index, int p_to_pos) override;
virtual void remove_occlusion_layer(int p_index) override;
virtual void add_physics_layer(int p_index) override;
virtual void move_physics_layer(int p_from_index, int p_to_pos) override;
virtual void remove_physics_layer(int p_index) override;
virtual void add_terrain_set(int p_index) override;
virtual void move_terrain_set(int p_from_index, int p_to_pos) override;
virtual void remove_terrain_set(int p_index) override;
virtual void add_terrain(int p_terrain_set, int p_index) override;
virtual void move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) override;
virtual void remove_terrain(int p_terrain_set, int p_index) override;
virtual void add_navigation_layer(int p_index) override;
virtual void move_navigation_layer(int p_from_index, int p_to_pos) override;
virtual void remove_navigation_layer(int p_index) override;
virtual void add_custom_data_layer(int p_index) override;
virtual void move_custom_data_layer(int p_from_index, int p_to_pos) override;
virtual void remove_custom_data_layer(int p_index) override;
virtual void reset_state() override;
virtual void notify_tile_data_properties_should_change();
virtual void add_occlusion_layer(int p_index);
virtual void move_occlusion_layer(int p_from_index, int p_to_pos);
virtual void remove_occlusion_layer(int p_index);
virtual void add_physics_layer(int p_index);
virtual void move_physics_layer(int p_from_index, int p_to_pos);
virtual void remove_physics_layer(int p_index);
virtual void add_terrain_set(int p_index);
virtual void move_terrain_set(int p_from_index, int p_to_pos);
virtual void remove_terrain_set(int p_index);
virtual void add_terrain(int p_terrain_set, int p_index);
virtual void move_terrain(int p_terrain_set, int p_from_index, int p_to_pos);
virtual void remove_terrain(int p_terrain_set, int p_index);
virtual void add_navigation_layer(int p_index);
virtual void move_navigation_layer(int p_from_index, int p_to_pos);
virtual void remove_navigation_layer(int p_index);
virtual void add_custom_data_layer(int p_index);
virtual void move_custom_data_layer(int p_from_index, int p_to_pos);
virtual void remove_custom_data_layer(int p_index);
virtual void reset_state();
// Base properties.
void set_texture(Ref<Texture2D> p_texture);
Ref<Texture2D> get_texture() const;
void set_texture(Ref<Texture> p_texture);
Ref<Texture> get_texture() const;
void set_margins(Vector2i p_margins);
Vector2i get_margins() const;
void set_separation(Vector2i p_separation);
@ -710,15 +710,15 @@ public:
// Base tiles.
void create_tile(const Vector2i p_atlas_coords, const Vector2i p_size = Vector2i(1, 1));
void remove_tile(Vector2i p_atlas_coords);
virtual bool has_tile(Vector2i p_atlas_coords) const override;
virtual bool has_tile(Vector2i p_atlas_coords) const;
void move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords = INVALID_ATLAS_COORDS, Vector2i p_new_size = Vector2i(-1, -1));
Vector2i get_tile_size_in_atlas(Vector2i p_atlas_coords) const;
virtual int get_tiles_count() const override;
virtual Vector2i get_tile_id(int p_index) const override;
virtual int get_tiles_count() const;
virtual Vector2i get_tile_id(int p_index) const;
bool has_room_for_tile(Vector2i p_atlas_coords, Vector2i p_size, int p_animation_columns, Vector2i p_animation_separation, int p_frames_count, Vector2i p_ignored_tile = INVALID_ATLAS_COORDS) const;
PackedVector2Array get_tiles_to_be_removed_on_change(Ref<Texture2D> p_texture, Vector2i p_margins, Vector2i p_separation, Vector2i p_texture_region_size);
PackedVector2Array get_tiles_to_be_removed_on_change(Ref<Texture> p_texture, Vector2i p_margins, Vector2i p_separation, Vector2i p_texture_region_size);
Vector2i get_tile_at_coords(Vector2i p_atlas_coords) const;
bool has_tiles_outside_texture() const;
@ -744,11 +744,11 @@ public:
int create_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_id_override = -1);
void remove_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile);
void set_alternative_tile_id(const Vector2i p_atlas_coords, int p_alternative_tile, int p_new_id);
virtual bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const override;
virtual bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const;
int get_next_alternative_tile_id(const Vector2i p_atlas_coords) const;
virtual int get_alternative_tiles_count(const Vector2i p_atlas_coords) const override;
virtual int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const override;
virtual int get_alternative_tiles_count(const Vector2i p_atlas_coords) const;
virtual int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const;
// Get data associated to a tile.
TileData *get_tile_data(const Vector2i p_atlas_coords, int p_alternative_tile) const;
@ -761,7 +761,7 @@ public:
static int alternative_no_transform(int p_alternative_id);
// Getters for texture and tile region (padded or not)
Ref<Texture2D> get_runtime_texture() const;
Ref<Texture> get_runtime_texture() const;
Rect2i get_runtime_tile_texture_region(Vector2i p_atlas_coords, int p_frame = 0) const;
~LayeredTileSetAtlasSource();
@ -790,14 +790,14 @@ protected:
public:
// Tiles.
int get_tiles_count() const override;
Vector2i get_tile_id(int p_tile_index) const override;
bool has_tile(Vector2i p_atlas_coords) const override;
int get_tiles_count() const;
Vector2i get_tile_id(int p_tile_index) const;
bool has_tile(Vector2i p_atlas_coords) const;
// Alternative tiles.
int get_alternative_tiles_count(const Vector2i p_atlas_coords) const override;
int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const override;
bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const override;
int get_alternative_tiles_count(const Vector2i p_atlas_coords) const;
int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const;
bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const;
// Scenes accessors. Lot are similar to "Alternative tiles".
int get_scene_tiles_count() { return get_alternative_tiles_count(Vector2i()); }