16 files changed, 813 insertions, 278 deletions

diff --git a/scene/3d/light_3d.cpp b/scene/3d/light_3d.cpp
index 81c0b5bb41..8478821ba1 100644
--- a/scene/3d/light_3d.cpp
+++ b/scene/3d/light_3d.cpp
@@ -375,15 +375,6 @@ DirectionalLight3D::ShadowMode DirectionalLight3D::get_shadow_mode() const {
 	return shadow_mode;
 }
 
-void DirectionalLight3D::set_shadow_depth_range(ShadowDepthRange p_range) {
-	shadow_depth_range = p_range;
-	RS::get_singleton()->light_directional_set_shadow_depth_range_mode(light, RS::LightDirectionalShadowDepthRangeMode(p_range));
-}
-
-DirectionalLight3D::ShadowDepthRange DirectionalLight3D::get_shadow_depth_range() const {
-	return shadow_depth_range;
-}
-
 void DirectionalLight3D::set_blend_splits(bool p_enable) {
 	blend_splits = p_enable;
 	RS::get_singleton()->light_directional_set_blend_splits(light, p_enable);
@@ -406,9 +397,6 @@ void DirectionalLight3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_shadow_mode", "mode"), &DirectionalLight3D::set_shadow_mode);
 	ClassDB::bind_method(D_METHOD("get_shadow_mode"), &DirectionalLight3D::get_shadow_mode);
 
-	ClassDB::bind_method(D_METHOD("set_shadow_depth_range", "mode"), &DirectionalLight3D::set_shadow_depth_range);
-	ClassDB::bind_method(D_METHOD("get_shadow_depth_range"), &DirectionalLight3D::get_shadow_depth_range);
-
 	ClassDB::bind_method(D_METHOD("set_blend_splits", "enabled"), &DirectionalLight3D::set_blend_splits);
 	ClassDB::bind_method(D_METHOD("is_blend_splits_enabled"), &DirectionalLight3D::is_blend_splits_enabled);
 
@@ -422,7 +410,6 @@ void DirectionalLight3D::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_shadow_split_3", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_param", "get_param", PARAM_SHADOW_SPLIT_3_OFFSET);
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_shadow_fade_start", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param", "get_param", PARAM_SHADOW_FADE_START);
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "directional_shadow_blend_splits"), "set_blend_splits", "is_blend_splits_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "directional_shadow_depth_range", PROPERTY_HINT_ENUM, "Stable,Optimized"), "set_shadow_depth_range", "get_shadow_depth_range");
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_shadow_max_distance", PROPERTY_HINT_RANGE, "0,8192,0.1,or_greater,exp"), "set_param", "get_param", PARAM_SHADOW_MAX_DISTANCE);
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_shadow_pancake_size", PROPERTY_HINT_RANGE, "0,1024,0.1,or_greater,exp"), "set_param", "get_param", PARAM_SHADOW_PANCAKE_SIZE);
 
@@ -431,9 +418,6 @@ void DirectionalLight3D::_bind_methods() {
 	BIND_ENUM_CONSTANT(SHADOW_ORTHOGONAL);
 	BIND_ENUM_CONSTANT(SHADOW_PARALLEL_2_SPLITS);
 	BIND_ENUM_CONSTANT(SHADOW_PARALLEL_4_SPLITS);
-
-	BIND_ENUM_CONSTANT(SHADOW_DEPTH_RANGE_STABLE);
-	BIND_ENUM_CONSTANT(SHADOW_DEPTH_RANGE_OPTIMIZED);
 }
 
 DirectionalLight3D::DirectionalLight3D() :
@@ -444,7 +428,6 @@ DirectionalLight3D::DirectionalLight3D() :
 	// Leave normal bias untouched as it doesn't benefit DirectionalLight3D as much as OmniLight3D.
 	set_param(PARAM_SHADOW_BIAS, 0.05);
 	set_shadow_mode(SHADOW_PARALLEL_4_SPLITS);
-	set_shadow_depth_range(SHADOW_DEPTH_RANGE_STABLE);
 	blend_splits = false;
 }
 
diff --git a/scene/3d/light_3d.h b/scene/3d/light_3d.h
index e145b08b74..d0308a3025 100644
--- a/scene/3d/light_3d.h
+++ b/scene/3d/light_3d.h
@@ -149,15 +149,9 @@ public:
 		SHADOW_PARALLEL_4_SPLITS,
 	};
 
-	enum ShadowDepthRange {
-		SHADOW_DEPTH_RANGE_STABLE = RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE,
-		SHADOW_DEPTH_RANGE_OPTIMIZED = RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED,
-	};
-
 private:
 	bool blend_splits;
 	ShadowMode shadow_mode;
-	ShadowDepthRange shadow_depth_range;
 	bool sky_only = false;
 
 protected:
@@ -167,9 +161,6 @@ public:
 	void set_shadow_mode(ShadowMode p_mode);
 	ShadowMode get_shadow_mode() const;
 
-	void set_shadow_depth_range(ShadowDepthRange p_range);
-	ShadowDepthRange get_shadow_depth_range() const;
-
 	void set_blend_splits(bool p_enable);
 	bool is_blend_splits_enabled() const;
 
@@ -180,7 +171,6 @@ public:
 };
 
 VARIANT_ENUM_CAST(DirectionalLight3D::ShadowMode)
-VARIANT_ENUM_CAST(DirectionalLight3D::ShadowDepthRange)
 
 class OmniLight3D : public Light3D {
 	GDCLASS(OmniLight3D, Light3D);
diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
index 4063d404d1..d42b505f7b 100644
--- a/scene/gui/control.cpp
+++ b/scene/gui/control.cpp
@@ -1488,7 +1488,7 @@ Point2 Control::get_global_position() const {
 
 Point2 Control::get_screen_position() const {
 	ERR_FAIL_COND_V(!is_inside_tree(), Point2());
-	Point2 global_pos = get_global_position();
+	Point2 global_pos = get_viewport()->get_canvas_transform().xform(get_global_position());
 	Window *w = Object::cast_to<Window>(get_viewport());
 	if (w && !w->is_embedding_subwindows()) {
 		global_pos += w->get_position();
diff --git a/scene/gui/split_container.cpp b/scene/gui/split_container.cpp
index df4cf9a740..9796b32c6b 100644
--- a/scene/gui/split_container.cpp
+++ b/scene/gui/split_container.cpp
@@ -38,7 +38,7 @@ Control *SplitContainer::_getch(int p_idx) const {
 
 	for (int i = 0; i < get_child_count(); i++) {
 		Control *c = Object::cast_to<Control>(get_child(i));
-		if (!c || !c->is_visible_in_tree()) {
+		if (!c || !c->is_visible()) {
 			continue;
 		}
 		if (c->is_set_as_top_level()) {
diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp
index aac15cd9a5..fd9e87604f 100644
--- a/scene/gui/tree.cpp
+++ b/scene/gui/tree.cpp
@@ -975,6 +975,9 @@ Size2 TreeItem::get_minimum_size(int p_column) {
 	}
 
 	// Icon.
+	if (cell.mode == CELL_MODE_CHECK) {
+		size.width += tree->cache.checked->get_width() + tree->cache.hseparation;
+	}
 	if (cell.icon.is_valid()) {
 		Size2i icon_size = cell.get_icon_size();
 		if (cell.icon_max_w > 0 && icon_size.width > cell.icon_max_w) {
@@ -1249,6 +1252,9 @@ void Tree::update_cache() {
 	cache.item_margin = get_theme_constant("item_margin");
 	cache.button_margin = get_theme_constant("button_margin");
 
+	cache.font_outline_color = get_theme_color("font_outline_color");
+	cache.font_outline_size = get_theme_constant("outline_size");
+
 	cache.draw_guides = get_theme_constant("draw_guides");
 	cache.guide_color = get_theme_color("guide_color");
 	cache.draw_relationship_lines = get_theme_constant("draw_relationship_lines");
@@ -1510,7 +1516,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 	int htotal = 0;
 
 	int label_h = compute_item_height(p_item);
-	bool rtl = is_layout_rtl();
+	bool rtl = cache.rtl;
 
 	/* Calculate height of the label part */
 	label_h += cache.vseparation;
@@ -1556,6 +1562,20 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 				}
 			}
 
+			if (!rtl && p_item->cells[i].buttons.size()) {
+				int button_w = 0;
+				for (int j = p_item->cells[i].buttons.size() - 1; j >= 0; j--) {
+					Ref<Texture2D> b = p_item->cells[i].buttons[j].texture;
+					button_w += b->get_size().width + cache.button_pressed->get_minimum_size().width + cache.button_margin;
+				}
+
+				int total_ofs = ofs - cache.offset.x;
+
+				if (total_ofs + w > p_draw_size.width) {
+					w = MAX(button_w, p_draw_size.width - total_ofs);
+				}
+			}
+
 			int bw = 0;
 			for (int j = p_item->cells[i].buttons.size() - 1; j >= 0; j--) {
 				Ref<Texture2D> b = p_item->cells[i].buttons[j].texture;
@@ -1680,8 +1700,8 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 			}
 
 			Color col = p_item->cells[i].custom_color ? p_item->cells[i].color : get_theme_color(p_item->cells[i].selected ? "font_selected_color" : "font_color");
-			Color font_outline_color = get_theme_color("font_outline_color");
-			int outline_size = get_theme_constant("outline_size");
+			Color font_outline_color = cache.font_outline_color;
+			int outline_size = cache.font_outline_size;
 			Color icon_col = p_item->cells[i].icon_color;
 
 			if (p_item->cells[i].dirty) {
@@ -2139,9 +2159,16 @@ void Tree::_range_click_timeout() {
 		Ref<InputEventMouseButton> mb;
 		mb.instantiate();
 
+		int x_limit = get_size().width - cache.bg->get_minimum_size().width;
+		if (h_scroll->is_visible()) {
+			x_limit -= h_scroll->get_minimum_size().width;
+		}
+
+		cache.rtl = is_layout_rtl();
+
 		propagate_mouse_activated = false; // done from outside, so signal handler can't clear the tree in the middle of emit (which is a common case)
 		blocked++;
-		propagate_mouse_event(pos + cache.offset, 0, 0, false, root, MOUSE_BUTTON_LEFT, mb);
+		propagate_mouse_event(pos + cache.offset, 0, 0, x_limit + cache.offset.width, false, root, MOUSE_BUTTON_LEFT, mb);
 		blocked--;
 
 		if (range_click_timer->is_one_shot()) {
@@ -2164,7 +2191,7 @@ void Tree::_range_click_timeout() {
 	}
 }
 
-int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_double_click, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod) {
+int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, int x_limit, bool p_double_click, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod) {
 	int item_h = compute_item_height(p_item) + cache.vseparation;
 
 	bool skip = (p_item == root && hide_root);
@@ -2189,6 +2216,9 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 		int col = -1;
 		int col_ofs = 0;
 		int col_width = 0;
+
+		int limit_w = x_limit;
+
 		for (int i = 0; i < columns.size(); i++) {
 			col_width = get_column_width(i);
 
@@ -2204,6 +2234,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 			if (x > col_width) {
 				col_ofs += col_width;
 				x -= col_width;
+				limit_w -= col_width;
 				continue;
 			}
 
@@ -2217,10 +2248,12 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 			int margin = x_ofs + cache.item_margin; //-cache.hseparation;
 			//int lm = cache.bg->get_margin(SIDE_LEFT);
 			col_width -= margin;
+			limit_w -= margin;
 			col_ofs += margin;
 			x -= margin;
 		} else {
 			col_width -= cache.hseparation;
+			limit_w -= cache.hseparation;
 			x -= cache.hseparation;
 		}
 
@@ -2234,6 +2267,16 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 		bool already_selected = c.selected;
 		bool already_cursor = (p_item == selected_item) && col == selected_col;
 
+		if (!cache.rtl && p_item->cells[col].buttons.size()) {
+			int button_w = 0;
+			for (int j = p_item->cells[col].buttons.size() - 1; j >= 0; j--) {
+				Ref<Texture2D> b = p_item->cells[col].buttons[j].texture;
+				button_w += b->get_size().width + cache.button_pressed->get_minimum_size().width + cache.button_margin;
+			}
+
+			col_width = MAX(button_w, MIN(limit_w, col_width));
+		}
+
 		for (int j = c.buttons.size() - 1; j >= 0; j--) {
 			Ref<Texture2D> b = c.buttons[j].texture;
 			int w = b->get_size().width + cache.button_pressed->get_minimum_size().width;
@@ -2255,6 +2298,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 				//emit_signal("button_pressed");
 				return -1;
 			}
+
 			col_width -= w + cache.button_margin;
 		}
 
@@ -2465,7 +2509,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 			TreeItem *c = p_item->first_child;
 
 			while (c) {
-				int child_h = propagate_mouse_event(new_pos, x_ofs, y_ofs, p_double_click, c, p_button, p_mod);
+				int child_h = propagate_mouse_event(new_pos, x_ofs, y_ofs, x_limit, p_double_click, c, p_button, p_mod);
 
 				if (child_h < 0) {
 					return -1; // break, stop propagating, no need to anymore
@@ -3143,8 +3187,14 @@ void Tree::_gui_input(Ref<InputEvent> p_event) {
 				pressing_for_editor = false;
 				propagate_mouse_activated = false;
 
+				int x_limit = get_size().width - cache.bg->get_minimum_size().width;
+				if (h_scroll->is_visible()) {
+					x_limit -= h_scroll->get_minimum_size().width;
+				}
+
+				cache.rtl = is_layout_rtl();
 				blocked++;
-				propagate_mouse_event(pos + cache.offset, 0, 0, b->is_double_click(), root, b->get_button_index(), b);
+				propagate_mouse_event(pos + cache.offset, 0, 0, x_limit + cache.offset.width, b->is_double_click(), root, b->get_button_index(), b);
 				blocked--;
 
 				if (pressing_for_editor) {
@@ -3496,6 +3546,9 @@ void Tree::_notification(int p_what) {
 		Point2 draw_ofs;
 		draw_ofs += bg->get_offset();
 		Size2 draw_size = get_size() - bg->get_minimum_size();
+		if (h_scroll->is_visible()) {
+			draw_size.width -= h_scroll->get_minimum_size().width;
+		}
 
 		bg->draw(ci, Rect2(Point2(), get_size()));
 
@@ -3504,6 +3557,8 @@ void Tree::_notification(int p_what) {
 		draw_ofs.y += tbh;
 		draw_size.y -= tbh;
 
+		cache.rtl = is_layout_rtl();
+
 		if (root && get_size().x > 0 && get_size().y > 0) {
 			draw_item(Point2(), draw_ofs, draw_size, root);
 		}
@@ -3515,7 +3570,7 @@ void Tree::_notification(int p_what) {
 				Ref<StyleBox> sb = (cache.click_type == Cache::CLICK_TITLE && cache.click_index == i) ? cache.title_button_pressed : ((cache.hover_type == Cache::CLICK_TITLE && cache.hover_index == i) ? cache.title_button_hover : cache.title_button);
 				Ref<Font> f = cache.tb_font;
 				Rect2 tbrect = Rect2(ofs2 - cache.offset.x, bg->get_margin(SIDE_TOP), get_column_width(i), tbh);
-				if (is_layout_rtl()) {
+				if (cache.rtl) {
 					tbrect.position.x = get_size().width - tbrect.size.x - tbrect.position.x;
 				}
 				sb->draw(ci, tbrect);
@@ -3761,6 +3816,36 @@ void Tree::set_column_expand(int p_column, bool p_expand) {
 	update();
 }
 
+void Tree::set_column_expand_ratio(int p_column, int p_ratio) {
+	ERR_FAIL_INDEX(p_column, columns.size());
+	columns.write[p_column].expand_ratio = p_ratio;
+	update();
+}
+
+void Tree::set_column_clip_content(int p_column, bool p_fit) {
+	ERR_FAIL_INDEX(p_column, columns.size());
+
+	columns.write[p_column].clip_content = p_fit;
+	update();
+}
+
+bool Tree::is_column_expanding(int p_column) const {
+	ERR_FAIL_INDEX_V(p_column, columns.size(), false);
+
+	return columns[p_column].expand;
+}
+int Tree::get_column_expand_ratio(int p_column) const {
+	ERR_FAIL_INDEX_V(p_column, columns.size(), 1);
+
+	return columns[p_column].expand_ratio;
+}
+
+bool Tree::is_column_clipping_content(int p_column) const {
+	ERR_FAIL_INDEX_V(p_column, columns.size(), false);
+
+	return columns[p_column].clip_content;
+}
+
 TreeItem *Tree::get_selected() const {
 	return selected_item;
 }
@@ -3820,11 +3905,14 @@ TreeItem *Tree::get_next_selected(TreeItem *p_item) {
 int Tree::get_column_minimum_width(int p_column) const {
 	ERR_FAIL_INDEX_V(p_column, columns.size(), -1);
 
-	if (columns[p_column].custom_min_width != 0) {
-		return columns[p_column].custom_min_width;
-	} else {
+	int min_width = columns[p_column].custom_min_width;
+
+	if (show_column_titles) {
+		min_width = MAX(cache.font->get_string_size(columns[p_column].title).width, min_width);
+	}
+
+	if (!columns[p_column].clip_content) {
 		int depth = 0;
-		int min_width = 0;
 		TreeItem *next;
 		for (TreeItem *item = get_root(); item; item = next) {
 			next = item->get_next_visible();
@@ -3848,13 +3936,16 @@ int Tree::get_column_minimum_width(int p_column) const {
 			}
 			min_width = MAX(min_width, item_size.width);
 		}
-		return min_width;
 	}
+
+	return min_width;
 }
 
 int Tree::get_column_width(int p_column) const {
 	ERR_FAIL_INDEX_V(p_column, columns.size(), -1);
 
+	int column_width = get_column_minimum_width(p_column);
+
 	if (columns[p_column].expand) {
 		int expand_area = get_size().width;
 
@@ -3868,31 +3959,24 @@ int Tree::get_column_width(int p_column) const {
 			expand_area -= v_scroll->get_combined_minimum_size().width;
 		}
 
-		int expanding_columns = 0;
 		int expanding_total = 0;
 
 		for (int i = 0; i < columns.size(); i++) {
-			if (!columns[i].expand) {
-				expand_area -= get_column_minimum_width(i);
-			} else {
-				expanding_total += get_column_minimum_width(i);
-				expanding_columns++;
+			expand_area -= get_column_minimum_width(i);
+			if (columns[i].expand) {
+				expanding_total += columns[i].expand_ratio;
 			}
 		}
 
-		if (expand_area < expanding_total) {
-			return get_column_minimum_width(p_column);
+		if (expand_area >= expanding_total && expanding_total > 0) {
+			column_width += expand_area * columns[p_column].expand_ratio / expanding_total;
 		}
+	}
 
-		ERR_FAIL_COND_V(expanding_columns == 0, -1); // shouldn't happen
-		if (expanding_total == 0) {
-			return 0;
-		} else {
-			return expand_area * get_column_minimum_width(p_column) / expanding_total;
-		}
-	} else {
-		return get_column_minimum_width(p_column);
+	if (p_column < columns.size() - 1) {
+		column_width += cache.hseparation;
 	}
+	return column_width;
 }
 
 void Tree::propagate_set_columns(TreeItem *p_item) {
@@ -4549,6 +4633,12 @@ void Tree::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_root"), &Tree::get_root);
 	ClassDB::bind_method(D_METHOD("set_column_custom_minimum_width", "column", "min_width"), &Tree::set_column_custom_minimum_width);
 	ClassDB::bind_method(D_METHOD("set_column_expand", "column", "expand"), &Tree::set_column_expand);
+	ClassDB::bind_method(D_METHOD("set_column_expand_ratio", "column", "ratio"), &Tree::set_column_expand_ratio);
+	ClassDB::bind_method(D_METHOD("set_column_clip_content", "column", "enable"), &Tree::set_column_clip_content);
+	ClassDB::bind_method(D_METHOD("is_column_expanding", "column"), &Tree::is_column_expanding);
+	ClassDB::bind_method(D_METHOD("is_column_clipping_content", "column"), &Tree::is_column_clipping_content);
+	ClassDB::bind_method(D_METHOD("get_column_expand_ratio", "column"), &Tree::get_column_expand_ratio);
+
 	ClassDB::bind_method(D_METHOD("get_column_width", "column"), &Tree::get_column_width);
 
 	ClassDB::bind_method(D_METHOD("set_hide_root", "enable"), &Tree::set_hide_root);
diff --git a/scene/gui/tree.h b/scene/gui/tree.h
index fd5fcd7838..10e6642303 100644
--- a/scene/gui/tree.h
+++ b/scene/gui/tree.h
@@ -411,7 +411,9 @@ private:
 
 	struct ColumnInfo {
 		int custom_min_width = 0;
+		int expand_ratio = 1;
 		bool expand = true;
+		bool clip_content = false;
 		String title;
 		Ref<TextLine> text_buf;
 		Dictionary opentype_features;
@@ -450,7 +452,7 @@ private:
 	void draw_item_rect(TreeItem::Cell &p_cell, const Rect2i &p_rect, const Color &p_color, const Color &p_icon_color, int p_ol_size, const Color &p_ol_color);
 	int draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2 &p_draw_size, TreeItem *p_item);
 	void select_single_item(TreeItem *p_selected, TreeItem *p_current, int p_col, TreeItem *p_prev = nullptr, bool *r_in_range = nullptr, bool p_force_deselect = false);
-	int propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_double_click, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod);
+	int propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, int x_limit, bool p_double_click, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod);
 	void _text_editor_submit(String p_text);
 	void _text_editor_modal_close();
 	void value_editor_changed(double p_value);
@@ -504,6 +506,7 @@ private:
 		Color parent_hl_line_color;
 		Color children_hl_line_color;
 		Color custom_button_font_highlight;
+		Color font_outline_color;
 
 		int hseparation = 0;
 		int vseparation = 0;
@@ -518,6 +521,7 @@ private:
 		int draw_guides = 0;
 		int scroll_border = 0;
 		int scroll_speed = 0;
+		int font_outline_size = 0;
 
 		enum ClickType {
 			CLICK_NONE,
@@ -540,6 +544,8 @@ private:
 
 		Point2i text_editor_position;
 
+		bool rtl = false;
+
 	} cache;
 
 	int _get_title_button_height() const;
@@ -547,6 +553,7 @@ private:
 	void _scroll_moved(float p_value);
 	HScrollBar *h_scroll;
 	VScrollBar *v_scroll;
+
 	bool h_scroll_enabled = true;
 	bool v_scroll_enabled = true;
 
@@ -632,8 +639,14 @@ public:
 
 	void set_column_custom_minimum_width(int p_column, int p_min_width);
 	void set_column_expand(int p_column, bool p_expand);
+	void set_column_expand_ratio(int p_column, int p_ratio);
+	void set_column_clip_content(int p_column, bool p_fit);
 	int get_column_minimum_width(int p_column) const;
 	int get_column_width(int p_column) const;
+	int get_column_expand_ratio(int p_column) const;
+
+	bool is_column_expanding(int p_column) const;
+	bool is_column_clipping_content(int p_column) const;
 
 	void set_hide_root(bool p_enabled);
 	bool is_root_hidden() const;
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index 319e589036..9a2e0c5230 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -3268,8 +3268,8 @@ Viewport::DebugDraw Viewport::get_debug_draw() const {
 	return debug_draw;
 }
 
-int Viewport::get_render_info(RenderInfo p_info) {
-	return RS::get_singleton()->viewport_get_render_info(viewport, RS::ViewportRenderInfo(p_info));
+int Viewport::get_render_info(RenderInfoType p_type, RenderInfo p_info) {
+	return RS::get_singleton()->viewport_get_render_info(viewport, RS::ViewportRenderInfoType(p_type), RS::ViewportRenderInfo(p_info));
 }
 
 void Viewport::set_snap_controls_to_pixels(bool p_enable) {
@@ -3499,7 +3499,7 @@ void Viewport::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_debug_draw", "debug_draw"), &Viewport::set_debug_draw);
 	ClassDB::bind_method(D_METHOD("get_debug_draw"), &Viewport::get_debug_draw);
 
-	ClassDB::bind_method(D_METHOD("get_render_info", "info"), &Viewport::get_render_info);
+	ClassDB::bind_method(D_METHOD("get_render_info", "type", "info"), &Viewport::get_render_info);
 
 	ClassDB::bind_method(D_METHOD("set_use_xr", "use"), &Viewport::set_use_xr);
 	ClassDB::bind_method(D_METHOD("is_using_xr"), &Viewport::is_using_xr);
@@ -3650,13 +3650,14 @@ void Viewport::_bind_methods() {
 	BIND_ENUM_CONSTANT(SCREEN_SPACE_AA_MAX);
 
 	BIND_ENUM_CONSTANT(RENDER_INFO_OBJECTS_IN_FRAME);
-	BIND_ENUM_CONSTANT(RENDER_INFO_VERTICES_IN_FRAME);
-	BIND_ENUM_CONSTANT(RENDER_INFO_MATERIAL_CHANGES_IN_FRAME);
-	BIND_ENUM_CONSTANT(RENDER_INFO_SHADER_CHANGES_IN_FRAME);
-	BIND_ENUM_CONSTANT(RENDER_INFO_SURFACE_CHANGES_IN_FRAME);
+	BIND_ENUM_CONSTANT(RENDER_INFO_PRIMITIVES_IN_FRAME);
 	BIND_ENUM_CONSTANT(RENDER_INFO_DRAW_CALLS_IN_FRAME);
 	BIND_ENUM_CONSTANT(RENDER_INFO_MAX);
 
+	BIND_ENUM_CONSTANT(RENDER_INFO_TYPE_VISIBLE);
+	BIND_ENUM_CONSTANT(RENDER_INFO_TYPE_SHADOW);
+	BIND_ENUM_CONSTANT(RENDER_INFO_TYPE_MAX);
+
 	BIND_ENUM_CONSTANT(DEBUG_DRAW_DISABLED);
 	BIND_ENUM_CONSTANT(DEBUG_DRAW_UNSHADED);
 	BIND_ENUM_CONSTANT(DEBUG_DRAW_LIGHTING);
diff --git a/scene/main/viewport.h b/scene/main/viewport.h
index 29491a1178..0f3bb8707d 100644
--- a/scene/main/viewport.h
+++ b/scene/main/viewport.h
@@ -115,14 +115,17 @@ public:
 
 	enum RenderInfo {
 		RENDER_INFO_OBJECTS_IN_FRAME,
-		RENDER_INFO_VERTICES_IN_FRAME,
-		RENDER_INFO_MATERIAL_CHANGES_IN_FRAME,
-		RENDER_INFO_SHADER_CHANGES_IN_FRAME,
-		RENDER_INFO_SURFACE_CHANGES_IN_FRAME,
+		RENDER_INFO_PRIMITIVES_IN_FRAME,
 		RENDER_INFO_DRAW_CALLS_IN_FRAME,
 		RENDER_INFO_MAX
 	};
 
+	enum RenderInfoType {
+		RENDER_INFO_TYPE_VISIBLE,
+		RENDER_INFO_TYPE_SHADOW,
+		RENDER_INFO_TYPE_MAX
+	};
+
 	enum DebugDraw {
 		DEBUG_DRAW_DISABLED,
 		DEBUG_DRAW_UNSHADED,
@@ -596,7 +599,7 @@ public:
 	void set_debug_draw(DebugDraw p_debug_draw);
 	DebugDraw get_debug_draw() const;
 
-	int get_render_info(RenderInfo p_info);
+	int get_render_info(RenderInfoType p_type, RenderInfo p_info);
 
 	void set_snap_controls_to_pixels(bool p_enable);
 	bool is_snap_controls_to_pixels_enabled() const;
@@ -699,6 +702,7 @@ VARIANT_ENUM_CAST(Viewport::SDFScale);
 VARIANT_ENUM_CAST(Viewport::SDFOversize);
 VARIANT_ENUM_CAST(SubViewport::ClearMode);
 VARIANT_ENUM_CAST(Viewport::RenderInfo);
+VARIANT_ENUM_CAST(Viewport::RenderInfoType);
 VARIANT_ENUM_CAST(Viewport::DefaultCanvasItemTextureFilter);
 VARIANT_ENUM_CAST(Viewport::DefaultCanvasItemTextureRepeat);
 
diff --git a/scene/main/window.cpp b/scene/main/window.cpp
index d793be1869..cf2a6b2adf 100644
--- a/scene/main/window.cpp
+++ b/scene/main/window.cpp
@@ -1393,6 +1393,8 @@ void Window::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("is_embedded"), &Window::is_embedded);
 
+	ClassDB::bind_method(D_METHOD("get_contents_minimum_size"), &Window::get_contents_minimum_size);
+
 	ClassDB::bind_method(D_METHOD("set_content_scale_size", "size"), &Window::set_content_scale_size);
 	ClassDB::bind_method(D_METHOD("get_content_scale_size"), &Window::get_content_scale_size);
 
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index d069d5e963..24a9b12733 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -774,6 +774,7 @@ void register_scene_types() {
 	ClassDB::register_class<AtlasTexture>();
 	ClassDB::register_class<MeshTexture>();
 	ClassDB::register_class<CurveTexture>();
+	ClassDB::register_class<Curve3Texture>();
 	ClassDB::register_class<GradientTexture>();
 	ClassDB::register_class<ProxyTexture>();
 	ClassDB::register_class<AnimatedTexture>();
@@ -936,14 +937,12 @@ void register_scene_types() {
 	ClassDB::add_compatibility_class("Physics2DServerSW", "PhysicsServer2DSW");
 	ClassDB::add_compatibility_class("Physics2DServer", "PhysicsServer2D");
 	ClassDB::add_compatibility_class("Physics2DShapeQueryParameters", "PhysicsShapeQueryParameters2D");
-	ClassDB::add_compatibility_class("Physics2DShapeQueryResult", "PhysicsShapeQueryResult2D");
 	ClassDB::add_compatibility_class("Physics2DTestMotionResult", "PhysicsTestMotionResult2D");
 	ClassDB::add_compatibility_class("PhysicsBody", "PhysicsBody3D");
 	ClassDB::add_compatibility_class("PhysicsDirectBodyState", "PhysicsDirectBodyState3D");
 	ClassDB::add_compatibility_class("PhysicsDirectSpaceState", "PhysicsDirectSpaceState3D");
 	ClassDB::add_compatibility_class("PhysicsServer", "PhysicsServer3D");
 	ClassDB::add_compatibility_class("PhysicsShapeQueryParameters", "PhysicsShapeQueryParameters3D");
-	ClassDB::add_compatibility_class("PhysicsShapeQueryResult", "PhysicsShapeQueryResult3D");
 	ClassDB::add_compatibility_class("PinJoint", "PinJoint3D");
 	ClassDB::add_compatibility_class("PlaneShape", "WorldMarginShape3D");
 	ClassDB::add_compatibility_class("ProceduralSky", "Sky");
diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index e522ce6774..4f7926d38d 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -345,7 +345,6 @@ void BaseMaterial3D::init_shaders() {
 	shader_names->refraction_texture_channel = "refraction_texture_channel";
 
 	shader_names->transmittance_color = "transmittance_color";
-	shader_names->transmittance_curve = "transmittance_curve";
 	shader_names->transmittance_depth = "transmittance_depth";
 	shader_names->transmittance_boost = "transmittance_boost";
 
@@ -692,7 +691,6 @@ void BaseMaterial3D::_update_shader() {
 		code += "uniform vec4 transmittance_color : hint_color;\n";
 		code += "uniform float transmittance_depth;\n";
 		code += "uniform sampler2D texture_subsurface_transmittance : hint_white," + texfilter_str + ";\n";
-		code += "uniform float transmittance_curve;\n";
 		code += "uniform float transmittance_boost;\n";
 	}
 
@@ -1194,7 +1192,6 @@ void BaseMaterial3D::_update_shader() {
 		code += "\tSSS_TRANSMITTANCE_COLOR=transmittance_color*trans_color_tex;\n";
 
 		code += "\tSSS_TRANSMITTANCE_DEPTH=transmittance_depth;\n";
-		code += "\tSSS_TRANSMITTANCE_CURVE=transmittance_curve;\n";
 		code += "\tSSS_TRANSMITTANCE_BOOST=transmittance_boost;\n";
 	}
 
@@ -1438,15 +1435,6 @@ float BaseMaterial3D::get_transmittance_depth() const {
 	return transmittance_depth;
 }
 
-void BaseMaterial3D::set_transmittance_curve(float p_curve) {
-	transmittance_curve = p_curve;
-	RS::get_singleton()->material_set_param(_get_material(), shader_names->transmittance_curve, p_curve);
-}
-
-float BaseMaterial3D::get_transmittance_curve() const {
-	return transmittance_curve;
-}
-
 void BaseMaterial3D::set_transmittance_boost(float p_boost) {
 	transmittance_boost = p_boost;
 	RS::get_singleton()->material_set_param(_get_material(), shader_names->transmittance_boost, p_boost);
@@ -1765,7 +1753,7 @@ void BaseMaterial3D::_validate_property(PropertyInfo &property) const {
 		property.usage = PROPERTY_USAGE_NONE;
 	}
 
-	if (flags[FLAG_SUBSURFACE_MODE_SKIN] && (property.name == "subsurf_scatter_transmittance_color" || property.name == "subsurf_scatter_transmittance_texture" || property.name == "subsurf_scatter_transmittance_curve")) {
+	if (flags[FLAG_SUBSURFACE_MODE_SKIN] && (property.name == "subsurf_scatter_transmittance_color" || property.name == "subsurf_scatter_transmittance_texture")) {
 		property.usage = PROPERTY_USAGE_NONE;
 	}
 
@@ -2269,9 +2257,6 @@ void BaseMaterial3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_transmittance_depth", "depth"), &BaseMaterial3D::set_transmittance_depth);
 	ClassDB::bind_method(D_METHOD("get_transmittance_depth"), &BaseMaterial3D::get_transmittance_depth);
 
-	ClassDB::bind_method(D_METHOD("set_transmittance_curve", "curve"), &BaseMaterial3D::set_transmittance_curve);
-	ClassDB::bind_method(D_METHOD("get_transmittance_curve"), &BaseMaterial3D::get_transmittance_curve);
-
 	ClassDB::bind_method(D_METHOD("set_transmittance_boost", "boost"), &BaseMaterial3D::set_transmittance_boost);
 	ClassDB::bind_method(D_METHOD("get_transmittance_boost"), &BaseMaterial3D::get_transmittance_boost);
 
@@ -2506,7 +2491,6 @@ void BaseMaterial3D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "subsurf_scatter_transmittance_color"), "set_transmittance_color", "get_transmittance_color");
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_transmittance_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_TRANSMITTANCE);
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_depth", PROPERTY_HINT_RANGE, "0.001,8,0.001,or_greater"), "set_transmittance_depth", "get_transmittance_depth");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_curve", PROPERTY_HINT_EXP_EASING, "0.01,16,0.01"), "set_transmittance_curve", "get_transmittance_curve");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_boost", PROPERTY_HINT_RANGE, "0.00,1.0,0.01"), "set_transmittance_boost", "get_transmittance_boost");
 
 	ADD_GROUP("Back Lighting", "backlight_");
@@ -2723,7 +2707,6 @@ BaseMaterial3D::BaseMaterial3D(bool p_orm) :
 	set_backlight(Color(0, 0, 0));
 	set_transmittance_color(Color(1, 1, 1, 1));
 	set_transmittance_depth(0.1);
-	set_transmittance_curve(1.0);
 	set_transmittance_boost(0.0);
 	set_refraction(0.05);
 	set_point_size(1);
diff --git a/scene/resources/material.h b/scene/resources/material.h
index cd91d05a60..80e5e94466 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -389,7 +389,6 @@ private:
 		StringName heightmap_scale;
 		StringName subsurface_scattering_strength;
 		StringName transmittance_color;
-		StringName transmittance_curve;
 		StringName transmittance_depth;
 		StringName transmittance_boost;
 		StringName backlight;
@@ -458,7 +457,6 @@ private:
 	float transmittance_amount;
 	Color transmittance_color;
 	float transmittance_depth;
-	float transmittance_curve;
 	float transmittance_boost;
 
 	Color backlight;
@@ -602,9 +600,6 @@ public:
 	void set_transmittance_depth(float p_depth);
 	float get_transmittance_depth() const;
 
-	void set_transmittance_curve(float p_curve);
-	float get_transmittance_curve() const;
-
 	void set_transmittance_boost(float p_boost);
 	float get_transmittance_boost() const;
 
diff --git a/scene/resources/mesh.cpp b/scene/resources/mesh.cpp
index ce942817c0..c5bfbc39db 100644
--- a/scene/resources/mesh.cpp
+++ b/scene/resources/mesh.cpp
@@ -590,157 +590,320 @@ Transform3D Mesh::get_builtin_bind_pose(int p_index) const {
 Mesh::Mesh() {
 }
 
-#if 0
-static Vector<uint8_t> _fix_array_compatibility(const Vector<uint8_t> &p_src, uint32_t p_format, uint32_t p_elements) {
-	enum ArrayType {
-		OLD_ARRAY_VERTEX = 0,
-		OLD_ARRAY_NORMAL = 1,
-		OLD_ARRAY_TANGENT = 2,
-		OLD_ARRAY_COLOR = 3,
-		OLD_ARRAY_TEX_UV = 4,
-		OLD_ARRAY_TEX_UV2 = 5,
-		OLD_ARRAY_BONES = 6,
-		OLD_ARRAY_WEIGHTS = 7,
-		OLD_ARRAY_INDEX = 8,
-		OLD_ARRAY_MAX = 9
-	};
-
-	enum ArrayFormat {
-		/* OLD_ARRAY FORMAT FLAGS */
-		OLD_ARRAY_FORMAT_VERTEX = 1 << OLD_ARRAY_VERTEX, // mandatory
-		OLD_ARRAY_FORMAT_NORMAL = 1 << OLD_ARRAY_NORMAL,
-		OLD_ARRAY_FORMAT_TANGENT = 1 << OLD_ARRAY_TANGENT,
-		OLD_ARRAY_FORMAT_COLOR = 1 << OLD_ARRAY_COLOR,
-		OLD_ARRAY_FORMAT_TEX_UV = 1 << OLD_ARRAY_TEX_UV,
-		OLD_ARRAY_FORMAT_TEX_UV2 = 1 << OLD_ARRAY_TEX_UV2,
-		OLD_ARRAY_FORMAT_BONES = 1 << OLD_ARRAY_BONES,
-		OLD_ARRAY_FORMAT_WEIGHTS = 1 << OLD_ARRAY_WEIGHTS,
-		OLD_ARRAY_FORMAT_INDEX = 1 << OLD_ARRAY_INDEX,
-
-		OLD_ARRAY_COMPRESS_BASE = (OLD_ARRAY_INDEX + 1),
-		OLD_ARRAY_COMPRESS_NORMAL = 1 << (OLD_ARRAY_NORMAL + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_TANGENT = 1 << (OLD_ARRAY_TANGENT + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_COLOR = 1 << (OLD_ARRAY_COLOR + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_TEX_UV = 1 << (OLD_ARRAY_TEX_UV + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_TEX_UV2 = 1 << (OLD_ARRAY_TEX_UV2 + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_INDEX = 1 << (OLD_ARRAY_INDEX + OLD_ARRAY_COMPRESS_BASE),
-		OLD_ARRAY_COMPRESS_DEFAULT = OLD_ARRAY_COMPRESS_NORMAL | OLD_ARRAY_COMPRESS_TANGENT | OLD_ARRAY_COMPRESS_COLOR | OLD_ARRAY_COMPRESS_TEX_UV | OLD_ARRAY_COMPRESS_TEX_UV2,
-
-		OLD_ARRAY_FLAG_USE_2D_VERTICES = OLD_ARRAY_COMPRESS_INDEX << 1,
-		OLD_ARRAY_FLAG_USE_DYNAMIC_UPDATE = OLD_ARRAY_COMPRESS_INDEX << 3,
-	};
-
-	bool vertex_16bit = p_format & ((1 << (OLD_ARRAY_VERTEX + OLD_ARRAY_COMPRESS_BASE)));
-	bool has_bones = (p_format & OLD_ARRAY_FORMAT_BONES);
-	bool bone_8 = has_bones && !(p_format & (OLD_ARRAY_COMPRESS_INDEX << 2));
-	bool weight_32 = has_bones && !(p_format & (OLD_ARRAY_COMPRESS_TEX_UV2 << 2));
-
-	print_line("convert vertex16: " + itos(vertex_16bit) + " convert bone 8 " + itos(bone_8) + " convert weight 32 " + itos(weight_32));
-
-	if (!vertex_16bit && !bone_8 && !weight_32) {
-		return p_src;
-	}
+enum OldArrayType {
+	OLD_ARRAY_VERTEX,
+	OLD_ARRAY_NORMAL,
+	OLD_ARRAY_TANGENT,
+	OLD_ARRAY_COLOR,
+	OLD_ARRAY_TEX_UV,
+	OLD_ARRAY_TEX_UV2,
+	OLD_ARRAY_BONES,
+	OLD_ARRAY_WEIGHTS,
+	OLD_ARRAY_INDEX,
+	OLD_ARRAY_MAX,
+};
 
-	bool vertex_2d = (p_format & (OLD_ARRAY_COMPRESS_INDEX << 1));
+enum OldArrayFormat {
+	/* OLD_ARRAY FORMAT FLAGS */
+	OLD_ARRAY_FORMAT_VERTEX = 1 << OLD_ARRAY_VERTEX, // mandatory
+	OLD_ARRAY_FORMAT_NORMAL = 1 << OLD_ARRAY_NORMAL,
+	OLD_ARRAY_FORMAT_TANGENT = 1 << OLD_ARRAY_TANGENT,
+	OLD_ARRAY_FORMAT_COLOR = 1 << OLD_ARRAY_COLOR,
+	OLD_ARRAY_FORMAT_TEX_UV = 1 << OLD_ARRAY_TEX_UV,
+	OLD_ARRAY_FORMAT_TEX_UV2 = 1 << OLD_ARRAY_TEX_UV2,
+	OLD_ARRAY_FORMAT_BONES = 1 << OLD_ARRAY_BONES,
+	OLD_ARRAY_FORMAT_WEIGHTS = 1 << OLD_ARRAY_WEIGHTS,
+	OLD_ARRAY_FORMAT_INDEX = 1 << OLD_ARRAY_INDEX,
+
+	OLD_ARRAY_COMPRESS_BASE = (OLD_ARRAY_INDEX + 1),
+	OLD_ARRAY_COMPRESS_VERTEX = 1 << (OLD_ARRAY_VERTEX + OLD_ARRAY_COMPRESS_BASE), // mandatory
+	OLD_ARRAY_COMPRESS_NORMAL = 1 << (OLD_ARRAY_NORMAL + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_TANGENT = 1 << (OLD_ARRAY_TANGENT + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_COLOR = 1 << (OLD_ARRAY_COLOR + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_TEX_UV = 1 << (OLD_ARRAY_TEX_UV + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_TEX_UV2 = 1 << (OLD_ARRAY_TEX_UV2 + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_BONES = 1 << (OLD_ARRAY_BONES + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_WEIGHTS = 1 << (OLD_ARRAY_WEIGHTS + OLD_ARRAY_COMPRESS_BASE),
+	OLD_ARRAY_COMPRESS_INDEX = 1 << (OLD_ARRAY_INDEX + OLD_ARRAY_COMPRESS_BASE),
+
+	OLD_ARRAY_FLAG_USE_2D_VERTICES = OLD_ARRAY_COMPRESS_INDEX << 1,
+	OLD_ARRAY_FLAG_USE_16_BIT_BONES = OLD_ARRAY_COMPRESS_INDEX << 2,
+	OLD_ARRAY_FLAG_USE_DYNAMIC_UPDATE = OLD_ARRAY_COMPRESS_INDEX << 3,
 
-	uint32_t src_stride = p_src.size() / p_elements;
-	uint32_t dst_stride = src_stride + (vertex_16bit ? 4 : 0) + (bone_8 ? 4 : 0) - (weight_32 ? 8 : 0);
+};
 
-	Vector<uint8_t> ret = p_src;
+static Array _convert_old_array(const Array &p_old) {
+	Array new_array;
+	new_array.resize(Mesh::ARRAY_MAX);
+	new_array[Mesh::ARRAY_VERTEX] = p_old[OLD_ARRAY_VERTEX];
+	new_array[Mesh::ARRAY_NORMAL] = p_old[OLD_ARRAY_NORMAL];
+	new_array[Mesh::ARRAY_TANGENT] = p_old[OLD_ARRAY_TANGENT];
+	new_array[Mesh::ARRAY_COLOR] = p_old[OLD_ARRAY_COLOR];
+	new_array[Mesh::ARRAY_TEX_UV] = p_old[OLD_ARRAY_TEX_UV];
+	new_array[Mesh::ARRAY_TEX_UV2] = p_old[OLD_ARRAY_TEX_UV2];
+	new_array[Mesh::ARRAY_BONES] = p_old[OLD_ARRAY_BONES];
+	new_array[Mesh::ARRAY_WEIGHTS] = p_old[OLD_ARRAY_WEIGHTS];
+	new_array[Mesh::ARRAY_INDEX] = p_old[OLD_ARRAY_INDEX];
+	return new_array;
+}
+
+static Mesh::PrimitiveType _old_primitives[7] = {
+	Mesh::PRIMITIVE_POINTS,
+	Mesh::PRIMITIVE_LINES,
+	Mesh::PRIMITIVE_LINE_STRIP,
+	Mesh::PRIMITIVE_LINES,
+	Mesh::PRIMITIVE_TRIANGLES,
+	Mesh::PRIMITIVE_TRIANGLE_STRIP,
+	Mesh::PRIMITIVE_TRIANGLE_STRIP
+};
 
-	ret.resize(dst_stride * p_elements);
-	{
-		uint8_t *w = ret.ptrw();
-		const uint8_t *r = p_src.ptr();
-
-		for (uint32_t i = 0; i < p_elements; i++) {
-			uint32_t remaining = src_stride;
-			const uint8_t *src = (const uint8_t *)(r + src_stride * i);
-			uint8_t *dst = (uint8_t *)(w + dst_stride * i);
-
-			if (!vertex_2d) { //3D
-				if (vertex_16bit) {
-					float *dstw = (float *)dst;
-					const uint16_t *srcr = (const uint16_t *)src;
-					dstw[0] = Math::half_to_float(srcr[0]);
-					dstw[1] = Math::half_to_float(srcr[1]);
-					dstw[2] = Math::half_to_float(srcr[2]);
-					remaining -= 8;
-					src += 8;
+void _fix_array_compatibility(const Vector<uint8_t> &p_src, uint32_t p_old_format, uint32_t p_new_format, uint32_t p_elements, Vector<uint8_t> &vertex_data, Vector<uint8_t> &attribute_data, Vector<uint8_t> &skin_data) {
+	uint32_t dst_vertex_stride;
+	uint32_t dst_attribute_stride;
+	uint32_t dst_skin_stride;
+	uint32_t dst_offsets[Mesh::ARRAY_MAX];
+	RenderingServer::get_singleton()->mesh_surface_make_offsets_from_format(p_new_format & (~RS::ARRAY_FORMAT_INDEX), p_elements, 0, dst_offsets, dst_vertex_stride, dst_attribute_stride, dst_skin_stride);
+
+	vertex_data.resize(dst_vertex_stride * p_elements);
+	attribute_data.resize(dst_attribute_stride * p_elements);
+	skin_data.resize(dst_skin_stride * p_elements);
+
+	uint8_t *dst_vertex_ptr = vertex_data.ptrw();
+	uint8_t *dst_attribute_ptr = attribute_data.ptrw();
+	uint8_t *dst_skin_ptr = skin_data.ptrw();
+
+	const uint8_t *src_vertex_ptr = p_src.ptr();
+	uint32_t src_vertex_stride = p_src.size() / p_elements;
+
+	uint32_t src_offset = 0;
+	for (uint32_t j = 0; j < OLD_ARRAY_INDEX; j++) {
+		if (!(p_old_format & (1 << j))) {
+			continue;
+		}
+		switch (j) {
+			case OLD_ARRAY_VERTEX: {
+				if (p_old_format & OLD_ARRAY_FLAG_USE_2D_VERTICES) {
+					if (p_old_format & OLD_ARRAY_COMPRESS_VERTEX) {
+						for (uint32_t i = 0; i < p_elements; i++) {
+							const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride];
+							float *dst = (float *)&dst_vertex_ptr[i * dst_vertex_stride];
+							dst[0] = Math::half_to_float(src[0]);
+							dst[1] = Math::half_to_float(src[1]);
+						}
+						src_offset += sizeof(uint16_t) * 2;
+					} else {
+						for (uint32_t i = 0; i < p_elements; i++) {
+							const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride];
+							float *dst = (float *)&dst_vertex_ptr[i * dst_vertex_stride];
+							dst[0] = src[0];
+							dst[1] = src[1];
+						}
+						src_offset += sizeof(float) * 2;
+					}
 				} else {
-					src += 12;
-					remaining -= 12;
+					if (p_old_format & OLD_ARRAY_COMPRESS_VERTEX) {
+						for (uint32_t i = 0; i < p_elements; i++) {
+							const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride];
+							float *dst = (float *)&dst_vertex_ptr[i * dst_vertex_stride];
+							dst[0] = Math::half_to_float(src[0]);
+							dst[1] = Math::half_to_float(src[1]);
+							dst[2] = Math::half_to_float(src[2]);
+						}
+						src_offset += sizeof(uint16_t) * 4; //+pad
+					} else {
+						for (uint32_t i = 0; i < p_elements; i++) {
+							const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride];
+							float *dst = (float *)&dst_vertex_ptr[i * dst_vertex_stride];
+							dst[0] = src[0];
+							dst[1] = src[1];
+							dst[2] = src[2];
+						}
+						src_offset += sizeof(float) * 3;
+					}
 				}
-				dst += 12;
-			} else {
-				if (vertex_16bit) {
-					float *dstw = (float *)dst;
-					const uint16_t *srcr = (const uint16_t *)src;
-					dstw[0] = Math::half_to_float(srcr[0]);
-					dstw[1] = Math::half_to_float(srcr[1]);
-					remaining -= 4;
-					src += 4;
+			} break;
+			case OLD_ARRAY_NORMAL: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_NORMAL) {
+					const float multiplier = 1.f / 127.f * 1023.0f;
+
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const int8_t *src = (const int8_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint32_t *dst = (uint32_t *)&dst_vertex_ptr[i * dst_vertex_stride + dst_offsets[Mesh::ARRAY_NORMAL]];
+
+						*dst = 0;
+						*dst |= CLAMP(int(src[0] * multiplier), 0, 1023);
+						*dst |= CLAMP(int(src[1] * multiplier), 0, 1023) << 10;
+						*dst |= CLAMP(int(src[2] * multiplier), 0, 1023) << 20;
+					}
+					src_offset += sizeof(uint32_t);
 				} else {
-					src += 8;
-					remaining -= 8;
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint32_t *dst = (uint32_t *)&dst_vertex_ptr[i * dst_vertex_stride + dst_offsets[Mesh::ARRAY_NORMAL]];
+
+						*dst = 0;
+						*dst |= CLAMP(int(src[0] * 1023.0), 0, 1023);
+						*dst |= CLAMP(int(src[1] * 1023.0), 0, 1023) << 10;
+						*dst |= CLAMP(int(src[2] * 1023.0), 0, 1023) << 20;
+					}
+					src_offset += sizeof(float) * 3;
 				}
-				dst += 8;
-			}
-
-			if (has_bones) {
-				remaining -= bone_8 ? 4 : 8;
-				remaining -= weight_32 ? 16 : 8;
-			}
-
-			for (uint32_t j = 0; j < remaining; j++) {
-				dst[j] = src[j];
-			}
-
-			if (has_bones) {
-				dst += remaining;
-				src += remaining;
 
-				if (bone_8) {
-					const uint8_t *src_bones = (const uint8_t *)src;
-					uint16_t *dst_bones = (uint16_t *)dst;
+			} break;
+			case OLD_ARRAY_TANGENT: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_TANGENT) {
+					const float multiplier = 1.f / 127.f * 1023.0f;
+
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const int8_t *src = (const int8_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint32_t *dst = (uint32_t *)&dst_vertex_ptr[i * dst_vertex_stride + dst_offsets[Mesh::ARRAY_TANGENT]];
+
+						*dst = 0;
+						*dst |= CLAMP(int(src[0] * multiplier), 0, 1023);
+						*dst |= CLAMP(int(src[1] * multiplier), 0, 1023) << 10;
+						*dst |= CLAMP(int(src[2] * multiplier), 0, 1023) << 20;
+						if (src[3] > 0) {
+							*dst |= 3 << 30;
+						}
+					}
+					src_offset += sizeof(uint32_t);
+				} else {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint32_t *dst = (uint32_t *)&dst_vertex_ptr[i * dst_vertex_stride + dst_offsets[Mesh::ARRAY_TANGENT]];
+
+						*dst = 0;
+						*dst |= CLAMP(int(src[0] * 1023.0), 0, 1023);
+						*dst |= CLAMP(int(src[1] * 1023.0), 0, 1023) << 10;
+						*dst |= CLAMP(int(src[2] * 1023.0), 0, 1023) << 20;
+						if (src[3] > 0) {
+							*dst |= 3 << 30;
+						}
+					}
+					src_offset += sizeof(float) * 4;
+				}
 
-					dst_bones[0] = src_bones[0];
-					dst_bones[1] = src_bones[1];
-					dst_bones[2] = src_bones[2];
-					dst_bones[3] = src_bones[3];
+			} break;
+			case OLD_ARRAY_COLOR: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_COLOR) {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint32_t *src = (const uint32_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint32_t *dst = (uint32_t *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_COLOR]];
 
-					src += 4;
+						*dst = *src;
+					}
+					src_offset += sizeof(uint32_t);
 				} else {
-					for (uint32_t j = 0; j < 8; j++) {
-						dst[j] = src[j];
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint8_t *dst = (uint8_t *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_COLOR]];
+
+						dst[0] = uint8_t(CLAMP(src[0] * 255.0, 0.0, 255.0));
+						dst[1] = uint8_t(CLAMP(src[1] * 255.0, 0.0, 255.0));
+						dst[2] = uint8_t(CLAMP(src[2] * 255.0, 0.0, 255.0));
+						dst[3] = uint8_t(CLAMP(src[3] * 255.0, 0.0, 255.0));
 					}
-
-					src += 8;
+					src_offset += sizeof(float) * 4;
 				}
+			} break;
+			case OLD_ARRAY_TEX_UV: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_TEX_UV) {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						float *dst = (float *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_TEX_UV]];
+
+						dst[0] = Math::half_to_float(src[0]);
+						dst[1] = Math::half_to_float(src[1]);
+					}
+					src_offset += sizeof(uint16_t) * 2;
+				} else {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						float *dst = (float *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_TEX_UV]];
 
-				dst += 8;
+						dst[0] = src[0];
+						dst[1] = src[1];
+					}
+					src_offset += sizeof(float) * 2;
+				}
 
-				if (weight_32) {
-					const float *src_weights = (const float *)src;
-					uint16_t *dst_weights = (uint16_t *)dst;
+			} break;
+			case OLD_ARRAY_TEX_UV2: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_TEX_UV2) {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						float *dst = (float *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_TEX_UV2]];
 
-					dst_weights[0] = CLAMP(src_weights[0] * 65535, 0, 65535); //16bits unorm
-					dst_weights[1] = CLAMP(src_weights[1] * 65535, 0, 65535);
-					dst_weights[2] = CLAMP(src_weights[2] * 65535, 0, 65535);
-					dst_weights[3] = CLAMP(src_weights[3] * 65535, 0, 65535);
+						dst[0] = Math::half_to_float(src[0]);
+						dst[1] = Math::half_to_float(src[1]);
+					}
+					src_offset += sizeof(uint16_t) * 2;
+				} else {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						float *dst = (float *)&dst_attribute_ptr[i * dst_attribute_stride + dst_offsets[Mesh::ARRAY_TEX_UV2]];
 
+						dst[0] = src[0];
+						dst[1] = src[1];
+					}
+					src_offset += sizeof(float) * 2;
+				}
+			} break;
+			case OLD_ARRAY_BONES: {
+				if (p_old_format & OLD_ARRAY_FLAG_USE_16_BIT_BONES) {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint16_t *dst = (uint16_t *)&dst_skin_ptr[i * dst_skin_stride + dst_offsets[Mesh::ARRAY_BONES]];
+
+						dst[0] = src[0];
+						dst[1] = src[1];
+						dst[2] = src[2];
+						dst[3] = src[3];
+					}
+					src_offset += sizeof(uint16_t) * 4;
 				} else {
-					for (uint32_t j = 0; j < 8; j++) {
-						dst[j] = src[j];
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint8_t *src = (const uint8_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint16_t *dst = (uint16_t *)&dst_skin_ptr[i * dst_skin_stride + dst_offsets[Mesh::ARRAY_BONES]];
+
+						dst[0] = src[0];
+						dst[1] = src[1];
+						dst[2] = src[2];
+						dst[3] = src[3];
 					}
+					src_offset += sizeof(uint8_t) * 4;
 				}
+			} break;
+			case OLD_ARRAY_WEIGHTS: {
+				if (p_old_format & OLD_ARRAY_COMPRESS_WEIGHTS) {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const uint16_t *src = (const uint16_t *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint16_t *dst = (uint16_t *)&dst_skin_ptr[i * dst_skin_stride + dst_offsets[Mesh::ARRAY_WEIGHTS]];
+
+						dst[0] = src[0];
+						dst[1] = src[1];
+						dst[2] = src[2];
+						dst[3] = src[3];
+					}
+					src_offset += sizeof(uint16_t) * 4;
+				} else {
+					for (uint32_t i = 0; i < p_elements; i++) {
+						const float *src = (const float *)&src_vertex_ptr[i * src_vertex_stride + src_offset];
+						uint16_t *dst = (uint16_t *)&dst_skin_ptr[i * dst_skin_stride + dst_offsets[Mesh::ARRAY_WEIGHTS]];
+
+						dst[0] = uint16_t(CLAMP(src[0] * 65535.0, 0, 65535.0));
+						dst[1] = uint16_t(CLAMP(src[1] * 65535.0, 0, 65535.0));
+						dst[2] = uint16_t(CLAMP(src[2] * 65535.0, 0, 65535.0));
+						dst[3] = uint16_t(CLAMP(src[3] * 65535.0, 0, 65535.0));
+					}
+					src_offset += sizeof(float) * 4;
+				}
+			} break;
+			default: {
 			}
 		}
 	}
-
-	return ret;
 }
-#endif
 
 bool ArrayMesh::_set(const StringName &p_name, const Variant &p_value) {
 	String sname = p_name;
@@ -779,10 +942,13 @@ bool ArrayMesh::_set(const StringName &p_name, const Variant &p_value) {
 		if (d.has("arrays")) {
 			//oldest format (2.x)
 			ERR_FAIL_COND_V(!d.has("morph_arrays"), false);
-			add_surface_from_arrays(PrimitiveType(int(d["primitive"])), d["arrays"], d["morph_arrays"]);
+			Array morph_arrays = d["morph_arrays"];
+			for (int i = 0; i < morph_arrays.size(); i++) {
+				morph_arrays[i] = _convert_old_array(morph_arrays[i]);
+			}
+			add_surface_from_arrays(_old_primitives[int(d["primitive"])], _convert_old_array(d["arrays"]), morph_arrays);
 
 		} else if (d.has("array_data")) {
-#if 0
 			//print_line("array data (old style");
 			//older format (3.x)
 			Vector<uint8_t> array_data = d["array_data"];
@@ -792,48 +958,76 @@ bool ArrayMesh::_set(const StringName &p_name, const Variant &p_value) {
 			}
 
 			ERR_FAIL_COND_V(!d.has("format"), false);
-			uint32_t format = d["format"];
+			uint32_t old_format = d["format"];
 
 			uint32_t primitive = d["primitive"];
 
-			uint32_t primitive_remap[7] = {
-				PRIMITIVE_POINTS,
-				PRIMITIVE_LINES,
-				PRIMITIVE_LINE_STRIP,
-				PRIMITIVE_LINES,
-				PRIMITIVE_TRIANGLES,
-				PRIMITIVE_TRIANGLE_STRIP,
-				PRIMITIVE_TRIANGLE_STRIP
-			};
-
-			primitive = primitive_remap[primitive]; //compatibility
+			primitive = _old_primitives[primitive]; //compatibility
 
 			ERR_FAIL_COND_V(!d.has("vertex_count"), false);
 			int vertex_count = d["vertex_count"];
 
-			array_data = _fix_array_compatibility(array_data, format, vertex_count);
+			uint32_t new_format = ARRAY_FORMAT_VERTEX;
+
+			if (old_format & OLD_ARRAY_FORMAT_NORMAL) {
+				new_format |= ARRAY_FORMAT_NORMAL;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_TANGENT) {
+				new_format |= ARRAY_FORMAT_TANGENT;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_COLOR) {
+				new_format |= ARRAY_FORMAT_COLOR;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_TEX_UV) {
+				new_format |= ARRAY_FORMAT_TEX_UV;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_TEX_UV2) {
+				new_format |= ARRAY_FORMAT_TEX_UV2;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_BONES) {
+				new_format |= ARRAY_FORMAT_BONES;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_WEIGHTS) {
+				new_format |= ARRAY_FORMAT_WEIGHTS;
+			}
+			if (old_format & OLD_ARRAY_FORMAT_INDEX) {
+				new_format |= ARRAY_FORMAT_INDEX;
+			}
+			if (old_format & OLD_ARRAY_FLAG_USE_2D_VERTICES) {
+				new_format |= OLD_ARRAY_FLAG_USE_2D_VERTICES;
+			}
+
+			Vector<uint8_t> vertex_array;
+			Vector<uint8_t> attribute_array;
+			Vector<uint8_t> skin_array;
+
+			_fix_array_compatibility(array_data, old_format, new_format, vertex_count, vertex_array, attribute_array, skin_array);
 
 			int index_count = 0;
 			if (d.has("index_count")) {
 				index_count = d["index_count"];
 			}
 
-			Vector<Vector<uint8_t>> blend_shapes;
+			Vector<uint8_t> blend_shapes;
 
 			if (d.has("blend_shape_data")) {
 				Array blend_shape_data = d["blend_shape_data"];
 				for (int i = 0; i < blend_shape_data.size(); i++) {
+					Vector<uint8_t> blend_vertex_array;
+					Vector<uint8_t> blend_attribute_array;
+					Vector<uint8_t> blend_skin_array;
+
 					Vector<uint8_t> shape = blend_shape_data[i];
-					shape = _fix_array_compatibility(shape, format, vertex_count);
+					_fix_array_compatibility(shape, old_format, new_format, vertex_count, blend_vertex_array, blend_attribute_array, blend_skin_array);
 
-					blend_shapes.push_back(shape);
+					blend_shapes.append_array(blend_vertex_array);
 				}
 			}
 
 			//clear unused flags
-			print_line("format pre: " + itos(format));
-			format &= ~uint32_t((1 << (ARRAY_VERTEX + ARRAY_COMPRESS_BASE)) | (ARRAY_COMPRESS_INDEX << 2) | (ARRAY_COMPRESS_TEX_UV2 << 2));
-			print_line("format post: " + itos(format));
+			print_line("format pre: " + itos(old_format));
+
+			print_line("format post: " + itos(new_format));
 
 			ERR_FAIL_COND_V(!d.has("aabb"), false);
 			AABB aabb = d["aabb"];
@@ -848,8 +1042,8 @@ bool ArrayMesh::_set(const StringName &p_name, const Variant &p_value) {
 				}
 			}
 
-			add_surface(format, PrimitiveType(primitive), array_data, vertex_count, array_index_data, index_count, aabb, blend_shapes, bone_aabb);
-#endif
+			add_surface(new_format, PrimitiveType(primitive), vertex_array, attribute_array, skin_array, vertex_count, array_index_data, index_count, aabb, blend_shapes, bone_aabb);
+
 		} else {
 			ERR_FAIL_V(false);
 		}
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index 14f9504dc9..d09a1d9f90 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -1407,14 +1407,26 @@ void CurveTexture::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_curve", "curve"), &CurveTexture::set_curve);
 	ClassDB::bind_method(D_METHOD("get_curve"), &CurveTexture::get_curve);
 
+	ClassDB::bind_method(D_METHOD("set_texture_mode", "texture_mode"), &CurveTexture::set_texture_mode);
+	ClassDB::bind_method(D_METHOD("get_texture_mode"), &CurveTexture::get_texture_mode);
+
 	ClassDB::bind_method(D_METHOD("_update"), &CurveTexture::_update);
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "width", PROPERTY_HINT_RANGE, "32,4096"), "set_width", "get_width");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_mode", PROPERTY_HINT_ENUM, "RGB,Red"), "set_texture_mode", "get_texture_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "curve", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_curve", "get_curve");
+
+	BIND_ENUM_CONSTANT(TEXTURE_MODE_RGB);
+	BIND_ENUM_CONSTANT(TEXTURE_MODE_RED);
 }
 
 void CurveTexture::set_width(int p_width) {
 	ERR_FAIL_COND(p_width < 32 || p_width > 4096);
+
+	if (_width == p_width) {
+		return;
+	}
+
 	_width = p_width;
 	_update();
 }
@@ -1450,7 +1462,7 @@ void CurveTexture::set_curve(Ref<Curve> p_curve) {
 
 void CurveTexture::_update() {
 	Vector<uint8_t> data;
-	data.resize(_width * sizeof(float));
+	data.resize(_width * sizeof(float) * (texture_mode == TEXTURE_MODE_RGB ? 3 : 1));
 
 	// The array is locked in that scope
 	{
@@ -1461,24 +1473,42 @@ void CurveTexture::_update() {
 			Curve &curve = **_curve;
 			for (int i = 0; i < _width; ++i) {
 				float t = i / static_cast<float>(_width);
-				wd[i] = curve.interpolate_baked(t);
+				if (texture_mode == TEXTURE_MODE_RGB) {
+					wd[i * 3 + 0] = curve.interpolate_baked(t);
+					wd[i * 3 + 1] = wd[i * 3 + 0];
+					wd[i * 3 + 2] = wd[i * 3 + 0];
+				} else {
+					wd[i] = curve.interpolate_baked(t);
+				}
 			}
 
 		} else {
 			for (int i = 0; i < _width; ++i) {
-				wd[i] = 0;
+				if (texture_mode == TEXTURE_MODE_RGB) {
+					wd[i * 3 + 0] = 0;
+					wd[i * 3 + 1] = 0;
+					wd[i * 3 + 2] = 0;
+				} else {
+					wd[i] = 0;
+				}
 			}
 		}
 	}
 
-	Ref<Image> image = memnew(Image(_width, 1, false, Image::FORMAT_RF, data));
+	Ref<Image> image = memnew(Image(_width, 1, false, texture_mode == TEXTURE_MODE_RGB ? Image::FORMAT_RGBF : Image::FORMAT_RF, data));
 
 	if (_texture.is_valid()) {
-		RID new_texture = RS::get_singleton()->texture_2d_create(image);
-		RS::get_singleton()->texture_replace(_texture, new_texture);
+		if (_current_texture_mode != texture_mode || _current_width != _width) {
+			RID new_texture = RS::get_singleton()->texture_2d_create(image);
+			RS::get_singleton()->texture_replace(_texture, new_texture);
+		} else {
+			RS::get_singleton()->texture_2d_update(_texture, image);
+		}
 	} else {
 		_texture = RS::get_singleton()->texture_2d_create(image);
 	}
+	_current_texture_mode = texture_mode;
+	_current_width = _width;
 
 	emit_changed();
 }
@@ -1487,6 +1517,17 @@ Ref<Curve> CurveTexture::get_curve() const {
 	return _curve;
 }
 
+void CurveTexture::set_texture_mode(TextureMode p_mode) {
+	if (texture_mode == p_mode) {
+		return;
+	}
+	texture_mode = p_mode;
+	_update();
+}
+CurveTexture::TextureMode CurveTexture::get_texture_mode() const {
+	return texture_mode;
+}
+
 RID CurveTexture::get_rid() const {
 	if (!_texture.is_valid()) {
 		_texture = RS::get_singleton()->texture_2d_placeholder_create();
@@ -1504,6 +1545,204 @@ CurveTexture::~CurveTexture() {
 
 //////////////////
 
+void Curve3Texture::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_width", "width"), &Curve3Texture::set_width);
+
+	ClassDB::bind_method(D_METHOD("set_curve_x", "curve"), &Curve3Texture::set_curve_x);
+	ClassDB::bind_method(D_METHOD("get_curve_x"), &Curve3Texture::get_curve_x);
+
+	ClassDB::bind_method(D_METHOD("set_curve_y", "curve"), &Curve3Texture::set_curve_y);
+	ClassDB::bind_method(D_METHOD("get_curve_y"), &Curve3Texture::get_curve_y);
+
+	ClassDB::bind_method(D_METHOD("set_curve_z", "curve"), &Curve3Texture::set_curve_z);
+	ClassDB::bind_method(D_METHOD("get_curve_z"), &Curve3Texture::get_curve_z);
+
+	ClassDB::bind_method(D_METHOD("_update"), &Curve3Texture::_update);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "width", PROPERTY_HINT_RANGE, "32,4096"), "set_width", "get_width");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "curve_x", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_curve_x", "get_curve_x");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "curve_y", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_curve_y", "get_curve_y");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "curve_z", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_curve_z", "get_curve_z");
+}
+
+void Curve3Texture::set_width(int p_width) {
+	ERR_FAIL_COND(p_width < 32 || p_width > 4096);
+
+	if (_width == p_width) {
+		return;
+	}
+
+	_width = p_width;
+	_update();
+}
+
+int Curve3Texture::get_width() const {
+	return _width;
+}
+
+void Curve3Texture::ensure_default_setup(float p_min, float p_max) {
+	if (_curve_x.is_null()) {
+		Ref<Curve> curve = Ref<Curve>(memnew(Curve));
+		curve->add_point(Vector2(0, 1));
+		curve->add_point(Vector2(1, 1));
+		curve->set_min_value(p_min);
+		curve->set_max_value(p_max);
+		set_curve_x(curve);
+	}
+
+	if (_curve_y.is_null()) {
+		Ref<Curve> curve = Ref<Curve>(memnew(Curve));
+		curve->add_point(Vector2(0, 1));
+		curve->add_point(Vector2(1, 1));
+		curve->set_min_value(p_min);
+		curve->set_max_value(p_max);
+		set_curve_y(curve);
+	}
+
+	if (_curve_z.is_null()) {
+		Ref<Curve> curve = Ref<Curve>(memnew(Curve));
+		curve->add_point(Vector2(0, 1));
+		curve->add_point(Vector2(1, 1));
+		curve->set_min_value(p_min);
+		curve->set_max_value(p_max);
+		set_curve_z(curve);
+	}
+}
+
+void Curve3Texture::set_curve_x(Ref<Curve> p_curve) {
+	if (_curve_x != p_curve) {
+		if (_curve_x.is_valid()) {
+			_curve_x->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update));
+		}
+		_curve_x = p_curve;
+		if (_curve_x.is_valid()) {
+			_curve_x->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update), varray(), CONNECT_REFERENCE_COUNTED);
+		}
+		_update();
+	}
+}
+
+void Curve3Texture::set_curve_y(Ref<Curve> p_curve) {
+	if (_curve_y != p_curve) {
+		if (_curve_y.is_valid()) {
+			_curve_y->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update));
+		}
+		_curve_y = p_curve;
+		if (_curve_y.is_valid()) {
+			_curve_y->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update), varray(), CONNECT_REFERENCE_COUNTED);
+		}
+		_update();
+	}
+}
+
+void Curve3Texture::set_curve_z(Ref<Curve> p_curve) {
+	if (_curve_z != p_curve) {
+		if (_curve_z.is_valid()) {
+			_curve_z->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update));
+		}
+		_curve_z = p_curve;
+		if (_curve_z.is_valid()) {
+			_curve_z->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &Curve3Texture::_update), varray(), CONNECT_REFERENCE_COUNTED);
+		}
+		_update();
+	}
+}
+
+void Curve3Texture::_update() {
+	Vector<uint8_t> data;
+	data.resize(_width * sizeof(float) * 3);
+
+	// The array is locked in that scope
+	{
+		uint8_t *wd8 = data.ptrw();
+		float *wd = (float *)wd8;
+
+		if (_curve_x.is_valid()) {
+			Curve &curve_x = **_curve_x;
+			for (int i = 0; i < _width; ++i) {
+				float t = i / static_cast<float>(_width);
+				wd[i * 3 + 0] = curve_x.interpolate_baked(t);
+			}
+
+		} else {
+			for (int i = 0; i < _width; ++i) {
+				wd[i * 3 + 0] = 0;
+			}
+		}
+
+		if (_curve_y.is_valid()) {
+			Curve &curve_y = **_curve_y;
+			for (int i = 0; i < _width; ++i) {
+				float t = i / static_cast<float>(_width);
+				wd[i * 3 + 1] = curve_y.interpolate_baked(t);
+			}
+
+		} else {
+			for (int i = 0; i < _width; ++i) {
+				wd[i * 3 + 1] = 0;
+			}
+		}
+
+		if (_curve_z.is_valid()) {
+			Curve &curve_z = **_curve_z;
+			for (int i = 0; i < _width; ++i) {
+				float t = i / static_cast<float>(_width);
+				wd[i * 3 + 2] = curve_z.interpolate_baked(t);
+			}
+
+		} else {
+			for (int i = 0; i < _width; ++i) {
+				wd[i * 3 + 2] = 0;
+			}
+		}
+	}
+
+	Ref<Image> image = memnew(Image(_width, 1, false, Image::FORMAT_RGBF, data));
+
+	if (_texture.is_valid()) {
+		if (_current_width != _width) {
+			RID new_texture = RS::get_singleton()->texture_2d_create(image);
+			RS::get_singleton()->texture_replace(_texture, new_texture);
+		} else {
+			RS::get_singleton()->texture_2d_update(_texture, image);
+		}
+	} else {
+		_texture = RS::get_singleton()->texture_2d_create(image);
+	}
+	_current_width = _width;
+
+	emit_changed();
+}
+
+Ref<Curve> Curve3Texture::get_curve_x() const {
+	return _curve_x;
+}
+
+Ref<Curve> Curve3Texture::get_curve_y() const {
+	return _curve_y;
+}
+
+Ref<Curve> Curve3Texture::get_curve_z() const {
+	return _curve_z;
+}
+
+RID Curve3Texture::get_rid() const {
+	if (!_texture.is_valid()) {
+		_texture = RS::get_singleton()->texture_2d_placeholder_create();
+	}
+	return _texture;
+}
+
+Curve3Texture::Curve3Texture() {}
+
+Curve3Texture::~Curve3Texture() {
+	if (_texture.is_valid()) {
+		RS::get_singleton()->free(_texture);
+	}
+}
+
+//////////////////
+
 GradientTexture::GradientTexture() {
 	_queue_update();
 }
diff --git a/scene/resources/texture.h b/scene/resources/texture.h
index 40193e3ff6..73390039cb 100644
--- a/scene/resources/texture.h
+++ b/scene/resources/texture.h
@@ -586,11 +586,19 @@ public:
 class CurveTexture : public Texture2D {
 	GDCLASS(CurveTexture, Texture2D);
 	RES_BASE_EXTENSION("curvetex")
+public:
+	enum TextureMode {
+		TEXTURE_MODE_RGB,
+		TEXTURE_MODE_RED,
+	};
 
 private:
 	mutable RID _texture;
 	Ref<Curve> _curve;
 	int _width = 2048;
+	int _current_width = 0;
+	TextureMode texture_mode = TEXTURE_MODE_RGB;
+	TextureMode _current_texture_mode = TEXTURE_MODE_RGB;
 
 	void _update();
 
@@ -601,6 +609,9 @@ public:
 	void set_width(int p_width);
 	int get_width() const override;
 
+	void set_texture_mode(TextureMode p_mode);
+	TextureMode get_texture_mode() const;
+
 	void ensure_default_setup(float p_min = 0, float p_max = 1);
 
 	void set_curve(Ref<Curve> p_curve);
@@ -614,18 +625,49 @@ public:
 	CurveTexture();
 	~CurveTexture();
 };
-/*
-	enum CubeMapSide {
-		CUBEMAP_LEFT,
-		CUBEMAP_RIGHT,
-		CUBEMAP_BOTTOM,
-		CUBEMAP_TOP,
-		CUBEMAP_FRONT,
-		CUBEMAP_BACK,
-	};
 
-*/
-//VARIANT_ENUM_CAST( Texture::CubeMapSide );
+VARIANT_ENUM_CAST(CurveTexture::TextureMode)
+
+class Curve3Texture : public Texture2D {
+	GDCLASS(Curve3Texture, Texture2D);
+	RES_BASE_EXTENSION("curvetex")
+
+private:
+	mutable RID _texture;
+	Ref<Curve> _curve_x;
+	Ref<Curve> _curve_y;
+	Ref<Curve> _curve_z;
+	int _width = 2048;
+	int _current_width = 0;
+
+	void _update();
+
+protected:
+	static void _bind_methods();
+
+public:
+	void set_width(int p_width);
+	int get_width() const override;
+
+	void ensure_default_setup(float p_min = 0, float p_max = 1);
+
+	void set_curve_x(Ref<Curve> p_curve);
+	Ref<Curve> get_curve_x() const;
+
+	void set_curve_y(Ref<Curve> p_curve);
+	Ref<Curve> get_curve_y() const;
+
+	void set_curve_z(Ref<Curve> p_curve);
+	Ref<Curve> get_curve_z() const;
+
+	virtual RID get_rid() const override;
+
+	virtual int get_height() const override { return 1; }
+	virtual bool has_alpha() const override { return false; }
+
+	Curve3Texture();
+	~Curve3Texture();
+};
 
 class GradientTexture : public Texture2D {
 	GDCLASS(GradientTexture, Texture2D);
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index 4f854ff229..deee22f05f 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -2245,22 +2245,22 @@ void TileSet::_bind_methods() {
 	BIND_ENUM_CONSTANT(TILE_OFFSET_AXIS_HORIZONTAL);
 	BIND_ENUM_CONSTANT(TILE_OFFSET_AXIS_VERTICAL);
 
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_RIGHT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_RIGHT_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_LEFT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_LEFT_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_CORNER);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
-	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_RIGHT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_BOTTOM_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_CORNER);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(CELL_NEIGHBOR_TOP_RIGHT_CORNER);
 
 	BIND_ENUM_CONSTANT(TERRAIN_MODE_MATCH_CORNERS_AND_SIDES);
 	BIND_ENUM_CONSTANT(TERRAIN_MODE_MATCH_CORNERS);