Implement Animation Blend Shape Tracks

* New track type BLEND_SHAPE
* Blend shapes are imported via this new track type
* Processing is more optimized (no longer relies on variants)
* Modified the Blend Shape API in MeshInstance3D to use indices rather than StringNames (more optimizes)
* Promo: Fixed a small bug in gizmo updating in Node3D that affected performance

Dedicated BlendShape tracks are required for both optimization and eventually implementing them in animation compression.

18 files changed, 736 insertions, 103 deletions

diff --git a/doc/classes/Animation.xml b/doc/classes/Animation.xml
index a35b784106..ebcced7dc4 100644
--- a/doc/classes/Animation.xml
+++ b/doc/classes/Animation.xml
@@ -201,6 +201,14 @@
 				Sets the value of the key identified by [code]key_idx[/code] to the given value. The [code]track_idx[/code] must be the index of a Bezier Track.
 			</description>
 		</method>
+		<method name="blend_shape_track_insert_key">
+			<return type="int" />
+			<argument index="0" name="track_idx" type="int" />
+			<argument index="1" name="time" type="float" />
+			<argument index="2" name="amount" type="float" />
+			<description>
+			</description>
+		</method>
 		<method name="clear">
 			<return type="void" />
 			<description>
@@ -552,16 +560,18 @@
 		</constant>
 		<constant name="TYPE_SCALE_3D" value="3" enum="TrackType">
 		</constant>
-		<constant name="TYPE_METHOD" value="4" enum="TrackType">
+		<constant name="TYPE_BLEND_SHAPE" value="4" enum="TrackType">
+		</constant>
+		<constant name="TYPE_METHOD" value="5" enum="TrackType">
 			Method tracks call functions with given arguments per key.
 		</constant>
-		<constant name="TYPE_BEZIER" value="5" enum="TrackType">
+		<constant name="TYPE_BEZIER" value="6" enum="TrackType">
 			Bezier tracks are used to interpolate a value using custom curves. They can also be used to animate sub-properties of vectors and colors (e.g. alpha value of a [Color]).
 		</constant>
-		<constant name="TYPE_AUDIO" value="6" enum="TrackType">
+		<constant name="TYPE_AUDIO" value="7" enum="TrackType">
 			Audio tracks are used to play an audio stream with either type of [AudioStreamPlayer]. The stream can be trimmed and previewed in the animation.
 		</constant>
-		<constant name="TYPE_ANIMATION" value="7" enum="TrackType">
+		<constant name="TYPE_ANIMATION" value="8" enum="TrackType">
 			Animation tracks play animations in other [AnimationPlayer] nodes.
 		</constant>
 		<constant name="INTERPOLATION_NEAREST" value="0" enum="InterpolationType">
diff --git a/doc/classes/MeshInstance3D.xml b/doc/classes/MeshInstance3D.xml
index 507a76197a..b72ce46310 100644
--- a/doc/classes/MeshInstance3D.xml
+++ b/doc/classes/MeshInstance3D.xml
@@ -41,6 +41,12 @@
 				This helper creates a [StaticBody3D] child node with a [ConcavePolygonShape3D] collision shape calculated from the mesh geometry. It's mainly used for testing.
 			</description>
 		</method>
+		<method name="find_blend_shape_by_name">
+			<return type="int" />
+			<argument index="0" name="name" type="StringName" />
+			<description>
+			</description>
+		</method>
 		<method name="get_active_material" qualifiers="const">
 			<return type="Material" />
 			<argument index="0" name="surface" type="int" />
@@ -48,6 +54,17 @@
 				Returns the [Material] that will be used by the [Mesh] when drawing. This can return the [member GeometryInstance3D.material_override], the surface override [Material] defined in this [MeshInstance3D], or the surface [Material] defined in the [Mesh]. For example, if [member GeometryInstance3D.material_override] is used, all surfaces will return the override material.
 			</description>
 		</method>
+		<method name="get_blend_shape_count" qualifiers="const">
+			<return type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="get_blend_shape_value" qualifiers="const">
+			<return type="float" />
+			<argument index="0" name="blend_shape_idx" type="int" />
+			<description>
+			</description>
+		</method>
 		<method name="get_surface_override_material" qualifiers="const">
 			<return type="Material" />
 			<argument index="0" name="surface" type="int" />
@@ -61,6 +78,13 @@
 				Returns the number of surface override materials. This is equivalent to [method Mesh.get_surface_count].
 			</description>
 		</method>
+		<method name="set_blend_shape_value">
+			<return type="void" />
+			<argument index="0" name="blend_shape_idx" type="int" />
+			<argument index="1" name="value" type="float" />
+			<description>
+			</description>
+		</method>
 		<method name="set_surface_override_material">
 			<return type="void" />
 			<argument index="0" name="surface" type="int" />
diff --git a/editor/animation_track_editor.cpp b/editor/animation_track_editor.cpp
index 2ee7f0ffa5..7f118532c9 100644
--- a/editor/animation_track_editor.cpp
+++ b/editor/animation_track_editor.cpp
@@ -198,6 +198,7 @@ public:
 				}
 
 			} break;
+			case Animation::TYPE_BLEND_SHAPE:
 			case Animation::TYPE_VALUE: {
 				if (name == "value") {
 					Variant value = p_value;
@@ -438,6 +439,7 @@ public:
 					return true;
 				}
 			} break;
+			case Animation::TYPE_BLEND_SHAPE:
 			case Animation::TYPE_VALUE: {
 				if (name == "value") {
 					r_ret = animation->track_get_key_value(track, key);
@@ -551,6 +553,9 @@ public:
 			case Animation::TYPE_SCALE_3D: {
 				p_list->push_back(PropertyInfo(Variant::VECTOR3, "scale"));
 			} break;
+			case Animation::TYPE_BLEND_SHAPE: {
+				p_list->push_back(PropertyInfo(Variant::FLOAT, "value"));
+			} break;
 			case Animation::TYPE_VALUE: {
 				Variant v = animation->track_get_key_value(track, key);
 
@@ -828,6 +833,7 @@ public:
 						undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, old);
 						update_obj = true;
 					} break;
+					case Animation::TYPE_BLEND_SHAPE:
 					case Animation::TYPE_VALUE: {
 						if (name == "value") {
 							Variant value = p_value;
@@ -1054,6 +1060,7 @@ public:
 						}
 
 					} break;
+					case Animation::TYPE_BLEND_SHAPE:
 					case Animation::TYPE_VALUE: {
 						if (name == "value") {
 							r_ret = animation->track_get_key_value(track, key);
@@ -1206,6 +1213,9 @@ public:
 				case Animation::TYPE_SCALE_3D: {
 					p_list->push_back(PropertyInfo(Variant::VECTOR3, "scale"));
 				} break;
+				case Animation::TYPE_BLEND_SHAPE: {
+					p_list->push_back(PropertyInfo(Variant::FLOAT, "value"));
+				} break;
 				case Animation::TYPE_VALUE: {
 					if (same_key_type) {
 						Variant v = animation->track_get_key_value(first_track, first_key);
@@ -1404,6 +1414,7 @@ void AnimationTimelineEdit::_notification(int p_what) {
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyXPosition"), SNAME("EditorIcons")), TTR("3D Position Track"));
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyXRotation"), SNAME("EditorIcons")), TTR("3D Rotation Track"));
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyXScale"), SNAME("EditorIcons")), TTR("3D Scale Track"));
+		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyBlendShape"), SNAME("EditorIcons")), TTR("Blend Shape Track"));
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyCall"), SNAME("EditorIcons")), TTR("Call Method Track"));
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyBezier"), SNAME("EditorIcons")), TTR("Bezier Curve Track"));
 		add_track->get_popup()->add_icon_item(get_theme_icon(SNAME("KeyAudio"), SNAME("EditorIcons")), TTR("Audio Playback Track"));
@@ -1872,11 +1883,12 @@ void AnimationTrackEdit::_notification(int p_what) {
 		Ref<Font> font = get_theme_font(SNAME("font"), SNAME("Label"));
 		int font_size = get_theme_font_size(SNAME("font_size"), SNAME("Label"));
 		Color color = get_theme_color(SNAME("font_color"), SNAME("Label"));
-		Ref<Texture2D> type_icons[8] = {
+		Ref<Texture2D> type_icons[9] = {
 			get_theme_icon(SNAME("KeyValue"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyTrackPosition"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyTrackRotation"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyTrackScale"), SNAME("EditorIcons")),
+			get_theme_icon(SNAME("KeyTrackBlendShape"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyCall"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyBezier"), SNAME("EditorIcons")),
 			get_theme_icon(SNAME("KeyAudio"), SNAME("EditorIcons")),
@@ -2067,7 +2079,7 @@ void AnimationTrackEdit::_notification(int p_what) {
 				interp_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
 				interp_mode_rect.size = icon->get_size();
 
-				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
+				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
 					draw_texture(icon, interp_mode_rect.position);
 				}
 				// Make it easier to click.
@@ -2077,7 +2089,7 @@ void AnimationTrackEdit::_notification(int p_what) {
 				ofs += icon->get_width() + hsep;
 				interp_mode_rect.size.x += hsep;
 
-				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
+				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
 					draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
 					interp_mode_rect.size.x += down_icon->get_width();
 				} else {
@@ -2100,7 +2112,7 @@ void AnimationTrackEdit::_notification(int p_what) {
 				loop_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
 				loop_mode_rect.size = icon->get_size();
 
-				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
+				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
 					draw_texture(icon, loop_mode_rect.position);
 				}
 
@@ -2110,7 +2122,7 @@ void AnimationTrackEdit::_notification(int p_what) {
 				ofs += icon->get_width() + hsep;
 				loop_mode_rect.size.x += hsep;
 
-				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
+				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D) {
 					draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
 					loop_mode_rect.size.x += down_icon->get_width();
 				} else {
@@ -2330,11 +2342,12 @@ void AnimationTrackEdit::set_animation_and_track(const Ref<Animation> &p_animati
 	track = p_track;
 	update();
 
-	Ref<Texture2D> type_icons[8] = {
+	Ref<Texture2D> type_icons[9] = {
 		get_theme_icon(SNAME("KeyValue"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyXPosition"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyXRotation"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyXScale"), SNAME("EditorIcons")),
+		get_theme_icon(SNAME("KeyBlendShape"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyCall"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyBezier"), SNAME("EditorIcons")),
 		get_theme_icon(SNAME("KeyAudio"), SNAME("EditorIcons")),
@@ -2516,6 +2529,10 @@ String AnimationTrackEdit::get_tooltip(const Point2 &p_pos) const {
 					Vector3 t = animation->track_get_key_value(track, key_idx);
 					text += "Scale: " + String(t) + "\n";
 				} break;
+				case Animation::TYPE_BLEND_SHAPE: {
+					float t = animation->track_get_key_value(track, key_idx);
+					text += "Blend Shape: " + itos(t) + "\n";
+				} break;
 				case Animation::TYPE_VALUE: {
 					const Variant &v = animation->track_get_key_value(track, key_idx);
 					text += "Type: " + Variant::get_type_name(v.get_type()) + "\n";
@@ -3369,6 +3386,8 @@ static bool track_type_is_resettable(Animation::TrackType p_type) {
 	switch (p_type) {
 		case Animation::TYPE_VALUE:
 			[[fallthrough]];
+		case Animation::TYPE_BLEND_SHAPE:
+			[[fallthrough]];
 		case Animation::TYPE_BEZIER:
 			[[fallthrough]];
 		case Animation::TYPE_POSITION_3D:
@@ -4049,6 +4068,7 @@ AnimationTrackEditor::TrackIndices AnimationTrackEditor::_confirm_insert(InsertD
 		case Animation::TYPE_POSITION_3D:
 		case Animation::TYPE_ROTATION_3D:
 		case Animation::TYPE_SCALE_3D:
+		case Animation::TYPE_BLEND_SHAPE:
 		case Animation::TYPE_VALUE: {
 			value = p_id.value;
 
@@ -4468,6 +4488,11 @@ void AnimationTrackEditor::_new_track_node_selected(NodePath p_path) {
 	ERR_FAIL_COND(!node);
 	NodePath path_to = root->get_path_to(node);
 
+	if (adding_track_type == Animation::TYPE_BLEND_SHAPE && !node->is_class("MeshInstance3D")) {
+		EditorNode::get_singleton()->show_warning(TTR("Blend Shape tracks only apply to MeshInstance3D nodes."));
+		return;
+	}
+
 	if ((adding_track_type == Animation::TYPE_POSITION_3D || adding_track_type == Animation::TYPE_ROTATION_3D || adding_track_type == Animation::TYPE_SCALE_3D) && !node->is_class("Node3D")) {
 		EditorNode::get_singleton()->show_warning(TTR("Position/Rotation/Scale 3D tracks only apply to 3D-based nodes."));
 		return;
@@ -4479,6 +4504,13 @@ void AnimationTrackEditor::_new_track_node_selected(NodePath p_path) {
 			prop_selector->set_type_filter(Vector<Variant::Type>());
 			prop_selector->select_property_from_instance(node);
 		} break;
+		case Animation::TYPE_BLEND_SHAPE: {
+			adding_track_path = path_to;
+			Vector<Variant::Type> filter;
+			filter.push_back(Variant::FLOAT);
+			prop_selector->set_type_filter(filter);
+			prop_selector->select_property_from_instance(node);
+		} break;
 		case Animation::TYPE_POSITION_3D:
 		case Animation::TYPE_ROTATION_3D:
 		case Animation::TYPE_SCALE_3D:
@@ -4710,6 +4742,7 @@ void AnimationTrackEditor::_insert_key_from_track(float p_ofs, int p_track) {
 			undo_redo->commit_action();
 
 		} break;
+		case Animation::TYPE_BLEND_SHAPE:
 		case Animation::TYPE_VALUE: {
 			NodePath bp;
 			Variant value;
@@ -5388,6 +5421,9 @@ void AnimationTrackEditor::_edit_menu_pressed(int p_option) {
 					case Animation::TYPE_SCALE_3D:
 						text += " (Scale)";
 						break;
+					case Animation::TYPE_BLEND_SHAPE:
+						text += " (BlendShape)";
+						break;
 					case Animation::TYPE_METHOD:
 						text += " (Methods)";
 						break;
diff --git a/editor/icons/KeyBlendShape.svg b/editor/icons/KeyBlendShape.svg
new file mode 100644
index 0000000000..42f7341942
--- /dev/null
+++ b/editor/icons/KeyBlendShape.svg
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="10"
+   viewBox="0 0 10 10"
+   width="10"
+   version="1.1"
+   id="svg80"
+   sodipodi:docname="KeyBlendShape.svg"
+   inkscape:version="1.1 (1:1.1+202106031931+af4d65493e)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs84" />
+  <sodipodi:namedview
+     id="namedview82"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="84.4"
+     inkscape:cx="2.6599526"
+     inkscape:cy="5.0059242"
+     inkscape:window-width="1848"
+     inkscape:window-height="1016"
+     inkscape:window-x="72"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg80" />
+  <rect
+     fill="#3cf34e"
+     height="6.1027"
+     ry=".76286"
+     transform="matrix(.70710678 -.70710678 .70710678 .70710678 0 -1042.4)"
+     width="6.1027"
+     x="-740.13947"
+     y="741.10779"
+     id="rect78"
+     style="fill:#5ad5c4;fill-opacity:1" />
+</svg>
diff --git a/editor/icons/KeyTrackBlendShape.svg b/editor/icons/KeyTrackBlendShape.svg
new file mode 100644
index 0000000000..e82f0d6a6f
--- /dev/null
+++ b/editor/icons/KeyTrackBlendShape.svg
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="10"
+   viewBox="0 0 10 10"
+   width="10"
+   version="1.1"
+   id="svg12"
+   sodipodi:docname="KeyTrackBlendShape.svg"
+   inkscape:version="1.1 (1:1.1+202106031931+af4d65493e)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs16" />
+  <sodipodi:namedview
+     id="namedview14"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="29.839906"
+     inkscape:cx="-3.5690461"
+     inkscape:cy="9.0985541"
+     inkscape:window-width="1848"
+     inkscape:window-height="1016"
+     inkscape:window-x="72"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg12" />
+  <ellipse
+     style="fill:none;fill-opacity:0.401212;stroke:none;stroke-width:4.7811;stroke-linejoin:round"
+     id="path921"
+     cx="-0.88986981"
+     cy="6.0959954"
+     rx="1.2495773"
+     ry="1.0867468" />
+  <path
+     id="path1910"
+     style="color:#000000;fill:#5ad5c4;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 4.5230825,1.1341567 c -2.1310744,0.017055 -3.86718737,1.7635044 -3.86718737,3.8984375 0,1.8778511 1.34348597,3.4523891 3.11718737,3.8164061 L 3.95277,7.5794693 C 2.7929991,7.3095662 1.9351921,6.2780435 1.9351921,5.0325942 c 0,-1.4262775 1.123493,-2.5732858 2.5390622,-2.6152344 v 0.017578 h 0.2011719 l 0.1796875,-1.28125 H 4.5230825 v -0.011719 c 0,-0.00263 -2.64e-5,-0.00518 0,-0.00781 z m 1.6816406,0.019531 -0.1796875,1.28125 h 1.3085937 c 0.078866,0 0.1230469,0.044181 0.1230469,0.1230469 v 4.9882815 c 0,0.07887 -0.044181,0.121093 -0.1230469,0.121094 H 5.2887075 L 5.10902,8.9486103 h 2.2246093 c 0.7663818,0 1.4042969,-0.635962 1.4042969,-1.402344 V 2.5579848 c 0,-0.7663818 -0.637915,-1.4042969 -1.4042969,-1.4042969 z" />
+</svg>
diff --git a/editor/import/editor_import_collada.cpp b/editor/import/editor_import_collada.cpp
index 52be03a1b1..ac8adedf2f 100644
--- a/editor/import/editor_import_collada.cpp
+++ b/editor/import/editor_import_collada.cpp
@@ -1710,7 +1710,7 @@ void ColladaImport::create_animation(int p_clip, bool p_import_value_tracks) {
 			NodeMap &nm = node_map[at.target];
 			String path = scene->get_path_to(nm.node);
 
-			animation->add_track(Animation::TYPE_VALUE);
+			animation->add_track(Animation::TYPE_BLEND_SHAPE);
 			int track = animation->get_track_count() - 1;
 
 			path = path + ":" + at.param;
@@ -1732,7 +1732,7 @@ void ColladaImport::create_animation(int p_clip, bool p_import_value_tracks) {
 					WARN_PRINT("Collada: Unexpected amount of value keys: " + itos(data.size()));
 				}
 
-				animation->track_insert_key(track, time, value);
+				animation->blend_shape_track_insert_key(track, time, value);
 			}
 
 			tracks_found = true;
diff --git a/editor/import/resource_importer_scene.cpp b/editor/import/resource_importer_scene.cpp
index c393d7f5fc..319e5ee25f 100644
--- a/editor/import/resource_importer_scene.cpp
+++ b/editor/import/resource_importer_scene.cpp
@@ -1036,6 +1036,10 @@ void ResourceImporterScene::_create_clips(AnimationPlayer *anim, const Array &p_
 							} else if (default_anim->track_get_type(j) == Animation::TYPE_VALUE) {
 								Variant var = default_anim->value_track_interpolate(j, from);
 								new_anim->track_insert_key(dtrack, 0, var);
+							} else if (default_anim->track_get_type(j) == Animation::TYPE_BLEND_SHAPE) {
+								float interp;
+								default_anim->blend_shape_track_interpolate(j, from, &interp);
+								new_anim->blend_shape_track_insert_key(dtrack, 0, interp);
 							}
 						}
 					}
@@ -1055,6 +1059,10 @@ void ResourceImporterScene::_create_clips(AnimationPlayer *anim, const Array &p_
 					} else if (default_anim->track_get_type(j) == Animation::TYPE_VALUE) {
 						Variant var = default_anim->track_get_key_value(j, k);
 						new_anim->track_insert_key(dtrack, kt - from, var);
+					} else if (default_anim->track_get_type(j) == Animation::TYPE_BLEND_SHAPE) {
+						float interp;
+						default_anim->blend_shape_track_get_key(j, k, &interp);
+						new_anim->blend_shape_track_insert_key(dtrack, kt - from, interp);
 					}
 				}
 
@@ -1074,6 +1082,10 @@ void ResourceImporterScene::_create_clips(AnimationPlayer *anim, const Array &p_
 					} else if (default_anim->track_get_type(j) == Animation::TYPE_VALUE) {
 						Variant var = default_anim->value_track_interpolate(j, to);
 						new_anim->track_insert_key(dtrack, to - from, var);
+					} else if (default_anim->track_get_type(j) == Animation::TYPE_BLEND_SHAPE) {
+						float interp;
+						default_anim->blend_shape_track_interpolate(j, to, &interp);
+						new_anim->blend_shape_track_insert_key(dtrack, to - from, interp);
 					}
 				}
 			}
@@ -1105,6 +1117,12 @@ void ResourceImporterScene::_create_clips(AnimationPlayer *anim, const Array &p_
 					new_anim->track_insert_key(dtrack, 0, var);
 					Variant to_var = default_anim->value_track_interpolate(j, to);
 					new_anim->track_insert_key(dtrack, to - from, to_var);
+				} else if (default_anim->track_get_type(j) == Animation::TYPE_BLEND_SHAPE) {
+					float interp;
+					default_anim->blend_shape_track_interpolate(j, from, &interp);
+					new_anim->blend_shape_track_insert_key(dtrack, 0, interp);
+					default_anim->blend_shape_track_interpolate(j, to, &interp);
+					new_anim->blend_shape_track_insert_key(dtrack, to - from, interp);
 				}
 			}
 		}
@@ -1652,7 +1670,7 @@ void ResourceImporterScene::_optimize_track_usage(AnimationPlayer *p_player, Ani
 	ERR_FAIL_COND(parent == nullptr);
 	OrderedHashMap<NodePath, uint32_t> used_tracks[TRACK_CHANNEL_MAX];
 	bool tracks_to_add = false;
-	static const Animation::TrackType track_types[TRACK_CHANNEL_MAX] = { Animation::TYPE_POSITION_3D, Animation::TYPE_ROTATION_3D, Animation::TYPE_SCALE_3D };
+	static const Animation::TrackType track_types[TRACK_CHANNEL_MAX] = { Animation::TYPE_POSITION_3D, Animation::TYPE_ROTATION_3D, Animation::TYPE_SCALE_3D, Animation::TYPE_BLEND_SHAPE };
 	for (const StringName &I : anims) {
 		Ref<Animation> anim = p_player->get_animation(I);
 		for (int i = 0; i < anim->get_track_count(); i++) {
@@ -1710,67 +1728,84 @@ void ResourceImporterScene::_optimize_track_usage(AnimationPlayer *p_player, Ani
 
 				NodePath path = J.key();
 				Node *n = parent->get_node(path);
-				Skeleton3D *skel = Object::cast_to<Skeleton3D>(n);
-				Node3D *n3d = Object::cast_to<Node3D>(n);
-				Vector3 loc;
-				Quaternion rot;
-				Vector3 scale;
-				if (skel && path.get_subname_count() > 0) {
-					StringName bone = path.get_subname(0);
-					int bone_idx = skel->find_bone(bone);
-					if (bone_idx == -1) {
-						continue;
+
+				if (j == TRACK_CHANNEL_BLEND_SHAPE) {
+					MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(n);
+					if (mi && path.get_subname_count() > 0) {
+						StringName bs = path.get_subname(0);
+						bool valid;
+						float value = mi->get(bs, &valid);
+						if (valid) {
+							int track_idx = anim->add_track(track_types[j]);
+							anim->track_set_path(track_idx, path);
+							anim->track_set_imported(track_idx, true);
+							anim->blend_shape_track_insert_key(track_idx, 0, value);
+						}
 					}
-					skel->get_bone_pose(bone_idx);
-					loc = skel->get_bone_pose_position(bone_idx);
-					rot = skel->get_bone_pose_rotation(bone_idx);
-					scale = skel->get_bone_pose_scale(bone_idx);
-				} else if (n3d) {
-					loc = n3d->get_position();
-					rot = n3d->get_transform().basis.get_rotation_quaternion();
-					scale = n3d->get_scale();
+
 				} else {
-					continue;
-				}
+					Skeleton3D *skel = Object::cast_to<Skeleton3D>(n);
+					Node3D *n3d = Object::cast_to<Node3D>(n);
+					Vector3 loc;
+					Quaternion rot;
+					Vector3 scale;
+					if (skel && path.get_subname_count() > 0) {
+						StringName bone = path.get_subname(0);
+						int bone_idx = skel->find_bone(bone);
+						if (bone_idx == -1) {
+							continue;
+						}
+						skel->get_bone_pose(bone_idx);
+						loc = skel->get_bone_pose_position(bone_idx);
+						rot = skel->get_bone_pose_rotation(bone_idx);
+						scale = skel->get_bone_pose_scale(bone_idx);
+					} else if (n3d) {
+						loc = n3d->get_position();
+						rot = n3d->get_transform().basis.get_rotation_quaternion();
+						scale = n3d->get_scale();
+					} else {
+						continue;
+					}
 
-				// Ensure insertion keeps tracks together and ordered by type (loc/rot/scale)
-				int insert_at_pos = -1;
-				for (int k = 0; k < anim->get_track_count(); k++) {
-					NodePath tpath = anim->track_get_path(k);
-
-					if (path == tpath) {
-						Animation::TrackType ttype = anim->track_get_type(k);
-						if (insert_at_pos == -1) {
-							// First insert, determine whether replacing or kicking back
-							if (track_types[j] < ttype) {
-								insert_at_pos = k;
-								break; // No point in continuing.
-							} else {
+					// Ensure insertion keeps tracks together and ordered by type (loc/rot/scale)
+					int insert_at_pos = -1;
+					for (int k = 0; k < anim->get_track_count(); k++) {
+						NodePath tpath = anim->track_get_path(k);
+
+						if (path == tpath) {
+							Animation::TrackType ttype = anim->track_get_type(k);
+							if (insert_at_pos == -1) {
+								// First insert, determine whether replacing or kicking back
+								if (track_types[j] < ttype) {
+									insert_at_pos = k;
+									break; // No point in continuing.
+								} else {
+									insert_at_pos = k + 1;
+								}
+							} else if (ttype < track_types[j]) {
+								// Kick back.
 								insert_at_pos = k + 1;
 							}
-						} else if (ttype < track_types[j]) {
-							// Kick back.
-							insert_at_pos = k + 1;
+						} else if (insert_at_pos >= 0) {
+							break;
 						}
-					} else if (insert_at_pos >= 0) {
-						break;
 					}
-				}
-				int track_idx = anim->add_track(track_types[j], insert_at_pos);
-
-				anim->track_set_path(track_idx, path);
-				anim->track_set_imported(track_idx, true);
-				switch (j) {
-					case TRACK_CHANNEL_POSITION: {
-						anim->position_track_insert_key(track_idx, 0, loc);
-					} break;
-					case TRACK_CHANNEL_ROTATION: {
-						anim->rotation_track_insert_key(track_idx, 0, rot);
-					} break;
-					case TRACK_CHANNEL_SCALE: {
-						anim->scale_track_insert_key(track_idx, 0, scale);
-					} break;
-					default: {
+					int track_idx = anim->add_track(track_types[j], insert_at_pos);
+
+					anim->track_set_path(track_idx, path);
+					anim->track_set_imported(track_idx, true);
+					switch (j) {
+						case TRACK_CHANNEL_POSITION: {
+							anim->position_track_insert_key(track_idx, 0, loc);
+						} break;
+						case TRACK_CHANNEL_ROTATION: {
+							anim->rotation_track_insert_key(track_idx, 0, rot);
+						} break;
+						case TRACK_CHANNEL_SCALE: {
+							anim->scale_track_insert_key(track_idx, 0, scale);
+						} break;
+						default: {
+						}
 					}
 				}
 			}
diff --git a/editor/import/resource_importer_scene.h b/editor/import/resource_importer_scene.h
index fab602b8ff..e1e7046be5 100644
--- a/editor/import/resource_importer_scene.h
+++ b/editor/import/resource_importer_scene.h
@@ -207,6 +207,7 @@ class ResourceImporterScene : public ResourceImporter {
 		TRACK_CHANNEL_POSITION,
 		TRACK_CHANNEL_ROTATION,
 		TRACK_CHANNEL_SCALE,
+		TRACK_CHANNEL_BLEND_SHAPE,
 		TRACK_CHANNEL_MAX
 	};
 
diff --git a/modules/gltf/gltf_document.cpp b/modules/gltf/gltf_document.cpp
index 70df62de6a..7d4bd998f5 100644
--- a/modules/gltf/gltf_document.cpp
+++ b/modules/gltf/gltf_document.cpp
@@ -5991,12 +5991,11 @@ void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 			ERR_CONTINUE(mesh.is_null());
 			ERR_CONTINUE(mesh->get_mesh().is_null());
 			ERR_CONTINUE(mesh->get_mesh()->get_mesh().is_null());
-			const String prop = "blend_shapes/" + mesh->get_mesh()->get_blend_shape_name(i);
 
-			const String blend_path = String(node_path) + ":" + prop;
+			const String blend_path = String(node_path) + ":" + String(mesh->get_mesh()->get_blend_shape_name(i));
 
 			const int track_idx = animation->get_track_count();
-			animation->add_track(Animation::TYPE_VALUE);
+			animation->add_track(Animation::TYPE_BLEND_SHAPE);
 			animation->track_set_path(track_idx, blend_path);
 
 			// Only LINEAR and STEP (NEAREST) can be supported out of the box by Godot's Animation,
@@ -6007,7 +6006,7 @@ void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 				for (int j = 0; j < track.weight_tracks[i].times.size(); j++) {
 					const float t = track.weight_tracks[i].times[j];
 					const float attribs = track.weight_tracks[i].values[j];
-					animation->track_insert_key(track_idx, t, attribs);
+					animation->blend_shape_track_insert_key(track_idx, t, attribs);
 				}
 			} else {
 				// CATMULLROMSPLINE or CUBIC_SPLINE have to be baked, apologies.
@@ -6015,7 +6014,8 @@ void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 				double time = 0.0;
 				bool last = false;
 				while (true) {
-					_interpolate_track<float>(track.weight_tracks[i].times, track.weight_tracks[i].values, time, gltf_interp);
+					float blend = _interpolate_track<float>(track.weight_tracks[i].times, track.weight_tracks[i].values, time, gltf_interp);
+					animation->blend_shape_track_insert_key(track_idx, time, blend);
 					if (last) {
 						break;
 					}
@@ -6459,7 +6459,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 			if (!tracks.has(mesh_index)) {
 				for (int32_t shape_i = 0; shape_i < mesh->get_blend_shape_count(); shape_i++) {
 					String shape_name = mesh->get_blend_shape_name(shape_i);
-					NodePath shape_path = String(path) + ":blend_shapes/" + shape_name;
+					NodePath shape_path = String(path) + ":" + shape_name;
 					int32_t shape_track_i = animation->find_track(shape_path);
 					if (shape_track_i == -1) {
 						GLTFAnimation::Channel<float> weight;
diff --git a/scene/3d/mesh_instance_3d.cpp b/scene/3d/mesh_instance_3d.cpp
index cfd90e5da0..c148f95461 100644
--- a/scene/3d/mesh_instance_3d.cpp
+++ b/scene/3d/mesh_instance_3d.cpp
@@ -42,10 +42,9 @@ bool MeshInstance3D::_set(const StringName &p_name, const Variant &p_value) {
 		return false;
 	}
 
-	Map<StringName, BlendShapeTrack>::Element *E = blend_shape_tracks.find(p_name);
+	Map<StringName, int>::Element *E = blend_shape_properties.find(p_name);
 	if (E) {
-		E->get().value = p_value;
-		RenderingServer::get_singleton()->instance_set_blend_shape_weight(get_instance(), E->get().idx, E->get().value);
+		set_blend_shape_value(E->get(), p_value);
 		return true;
 	}
 
@@ -67,9 +66,9 @@ bool MeshInstance3D::_get(const StringName &p_name, Variant &r_ret) const {
 		return false;
 	}
 
-	const Map<StringName, BlendShapeTrack>::Element *E = blend_shape_tracks.find(p_name);
+	const Map<StringName, int>::Element *E = blend_shape_properties.find(p_name);
 	if (E) {
-		r_ret = E->get().value;
+		r_ret = get_blend_shape_value(E->get());
 		return true;
 	}
 
@@ -86,7 +85,7 @@ bool MeshInstance3D::_get(const StringName &p_name, Variant &r_ret) const {
 
 void MeshInstance3D::_get_property_list(List<PropertyInfo> *p_list) const {
 	List<String> ls;
-	for (const KeyValue<StringName, BlendShapeTrack> &E : blend_shape_tracks) {
+	for (const KeyValue<StringName, int> &E : blend_shape_properties) {
 		ls.push_back(E.key);
 	}
 
@@ -114,25 +113,17 @@ void MeshInstance3D::set_mesh(const Ref<Mesh> &p_mesh) {
 
 	mesh = p_mesh;
 
-	blend_shape_tracks.clear();
 	if (mesh.is_valid()) {
-		for (int i = 0; i < mesh->get_blend_shape_count(); i++) {
-			BlendShapeTrack mt;
-			mt.idx = i;
-			mt.value = 0;
-			blend_shape_tracks["blend_shapes/" + String(mesh->get_blend_shape_name(i))] = mt;
-		}
-
 		mesh->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &MeshInstance3D::_mesh_changed));
-		surface_override_materials.resize(mesh->get_surface_count());
-
+		_mesh_changed();
 		set_base(mesh->get_rid());
 	} else {
+		blend_shape_tracks.clear();
+		blend_shape_properties.clear();
 		set_base(RID());
+		update_gizmos();
 	}
 
-	update_gizmos();
-
 	notify_property_list_changed();
 }
 
@@ -140,6 +131,35 @@ Ref<Mesh> MeshInstance3D::get_mesh() const {
 	return mesh;
 }
 
+int MeshInstance3D::get_blend_shape_count() const {
+	if (mesh.is_null()) {
+		return 0;
+	}
+	return mesh->get_blend_shape_count();
+}
+int MeshInstance3D::find_blend_shape_by_name(const StringName &p_name) {
+	if (mesh.is_null()) {
+		return -1;
+	}
+	for (int i = 0; i < mesh->get_blend_shape_count(); i++) {
+		if (mesh->get_blend_shape_name(i) == p_name) {
+			return i;
+		}
+	}
+	return -1;
+}
+float MeshInstance3D::get_blend_shape_value(int p_blend_shape) const {
+	ERR_FAIL_COND_V(mesh.is_null(), 0.0);
+	ERR_FAIL_INDEX_V(p_blend_shape, (int)blend_shape_tracks.size(), 0);
+	return blend_shape_tracks[p_blend_shape];
+}
+void MeshInstance3D::set_blend_shape_value(int p_blend_shape, float p_value) {
+	ERR_FAIL_COND(mesh.is_null());
+	ERR_FAIL_INDEX(p_blend_shape, (int)blend_shape_tracks.size());
+	blend_shape_tracks[p_blend_shape] = p_value;
+	RenderingServer::get_singleton()->instance_set_blend_shape_weight(get_instance(), p_blend_shape, p_value);
+}
+
 void MeshInstance3D::_resolve_skeleton_path() {
 	Ref<SkinReference> new_skin_reference;
 
@@ -357,6 +377,19 @@ Ref<Material> MeshInstance3D::get_active_material(int p_surface) const {
 void MeshInstance3D::_mesh_changed() {
 	ERR_FAIL_COND(mesh.is_null());
 	surface_override_materials.resize(mesh->get_surface_count());
+
+	uint32_t initialize_bs_from = blend_shape_tracks.size();
+	blend_shape_tracks.resize(mesh->get_blend_shape_count());
+
+	for (uint32_t i = 0; i < blend_shape_tracks.size(); i++) {
+		blend_shape_properties["blend_shapes/" + String(mesh->get_blend_shape_name(i))] = i;
+		if (i < initialize_bs_from) {
+			set_blend_shape_value(i, blend_shape_tracks[i]);
+		} else {
+			set_blend_shape_value(i, 0);
+		}
+	}
+
 	update_gizmos();
 }
 
@@ -459,6 +492,11 @@ void MeshInstance3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("create_multiple_convex_collisions"), &MeshInstance3D::create_multiple_convex_collisions);
 	ClassDB::set_method_flags("MeshInstance3D", "create_multiple_convex_collisions", METHOD_FLAGS_DEFAULT);
 
+	ClassDB::bind_method(D_METHOD("get_blend_shape_count"), &MeshInstance3D::get_blend_shape_count);
+	ClassDB::bind_method(D_METHOD("find_blend_shape_by_name", "name"), &MeshInstance3D::find_blend_shape_by_name);
+	ClassDB::bind_method(D_METHOD("get_blend_shape_value", "blend_shape_idx"), &MeshInstance3D::get_blend_shape_value);
+	ClassDB::bind_method(D_METHOD("set_blend_shape_value", "blend_shape_idx", "value"), &MeshInstance3D::set_blend_shape_value);
+
 	ClassDB::bind_method(D_METHOD("create_debug_tangents"), &MeshInstance3D::create_debug_tangents);
 	ClassDB::set_method_flags("MeshInstance3D", "create_debug_tangents", METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
 
diff --git a/scene/3d/mesh_instance_3d.h b/scene/3d/mesh_instance_3d.h
index beb7f6cf95..8f21726601 100644
--- a/scene/3d/mesh_instance_3d.h
+++ b/scene/3d/mesh_instance_3d.h
@@ -31,8 +31,8 @@
 #ifndef MESH_INSTANCE_H
 #define MESH_INSTANCE_H
 
+#include "core/templates/local_vector.h"
 #include "scene/3d/visual_instance_3d.h"
-
 class Skin;
 class SkinReference;
 
@@ -46,12 +46,8 @@ protected:
 	Ref<SkinReference> skin_ref;
 	NodePath skeleton_path = NodePath("..");
 
-	struct BlendShapeTrack {
-		int idx = 0;
-		float value = 0.0;
-	};
-
-	Map<StringName, BlendShapeTrack> blend_shape_tracks;
+	LocalVector<float> blend_shape_tracks;
+	Map<StringName, int> blend_shape_properties;
 	Vector<Ref<Material>> surface_override_materials;
 
 	void _mesh_changed();
@@ -75,6 +71,11 @@ public:
 	void set_skeleton_path(const NodePath &p_skeleton);
 	NodePath get_skeleton_path();
 
+	int get_blend_shape_count() const;
+	int find_blend_shape_by_name(const StringName &p_name);
+	float get_blend_shape_value(int p_blend_shape) const;
+	void set_blend_shape_value(int p_blend_shape, float p_value);
+
 	int get_surface_override_material_count() const;
 	void set_surface_override_material(int p_surface, const Ref<Material> &p_material);
 	Ref<Material> get_surface_override_material(int p_surface) const;
diff --git a/scene/3d/node_3d.cpp b/scene/3d/node_3d.cpp
index 272a06bce4..c96204cf60 100644
--- a/scene/3d/node_3d.cpp
+++ b/scene/3d/node_3d.cpp
@@ -371,6 +371,9 @@ void Node3D::update_gizmos() {
 	if (data.gizmos.is_empty()) {
 		return;
 	}
+	if (data.gizmos_dirty) {
+		return;
+	}
 	data.gizmos_dirty = true;
 	MessageQueue::get_singleton()->push_callable(callable_mp(this, &Node3D::_update_gizmos));
 #endif
@@ -467,6 +470,7 @@ Vector<Ref<Node3DGizmo>> Node3D::get_gizmos() const {
 void Node3D::_update_gizmos() {
 #ifdef TOOLS_ENABLED
 	if (data.gizmos_disabled || !is_inside_world() || !data.gizmos_dirty) {
+		data.gizmos_dirty = false;
 		return;
 	}
 	data.gizmos_dirty = false;
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 8407e0dd99..1f000d5f39 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -257,6 +257,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 		ERR_CONTINUE_MSG(!child, "On Animation: '" + p_anim->name + "', couldn't resolve track:  '" + String(a->track_get_path(i)) + "'."); // couldn't find the child node
 		ObjectID id = resource.is_valid() ? resource->get_instance_id() : child->get_instance_id();
 		int bone_idx = -1;
+		int blend_shape_idx = -1;
 
 #ifndef _3D_DISABLED
 		if (a->track_get_path(i).get_subname_count() == 1 && Object::cast_to<Skeleton3D>(child)) {
@@ -266,6 +267,22 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 				continue;
 			}
 		}
+
+		if (a->track_get_type(i) == Animation::TYPE_BLEND_SHAPE) {
+			MeshInstance3D *mi_3d = Object::cast_to<MeshInstance3D>(child);
+			if (!mi_3d) {
+				continue;
+			}
+			if (a->track_get_path(i).get_subname_count() != 1) {
+				continue;
+			}
+
+			blend_shape_idx = mi_3d->find_blend_shape_by_name(a->track_get_path(i).get_subname(0));
+			if (blend_shape_idx == -1) {
+				continue;
+			}
+		}
+
 #endif // _3D_DISABLED
 
 		{
@@ -277,6 +294,7 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 		TrackNodeCacheKey key;
 		key.id = id;
 		key.bone_idx = bone_idx;
+		key.blend_shape_idx = blend_shape_idx;
 
 		if (!node_cache_map.has(key)) {
 			node_cache_map[key] = TrackNodeCache();
@@ -334,6 +352,13 @@ void AnimationPlayer::_ensure_node_caches(AnimationData *p_anim, Node *p_root_ov
 				}
 			}
 		}
+
+		if (a->track_get_type(i) == Animation::TYPE_BLEND_SHAPE) {
+			// special cases and caches for transform tracks
+			node_cache->node_blend_shape = Object::cast_to<MeshInstance3D>(child);
+			node_cache->blend_shape_idx = blend_shape_idx;
+		}
+
 #endif // _3D_DISABLED
 
 		if (a->track_get_type(i) == Animation::TYPE_VALUE) {
@@ -481,6 +506,31 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, double
 				}
 #endif // _3D_DISABLED
 			} break;
+			case Animation::TYPE_BLEND_SHAPE: {
+#ifndef _3D_DISABLED
+				if (!nc->node_blend_shape) {
+					continue;
+				}
+
+				float blend;
+
+				Error err = a->blend_shape_track_interpolate(i, p_time, &blend);
+				//ERR_CONTINUE(err!=OK); //used for testing, should be removed
+
+				if (err != OK) {
+					continue;
+				}
+
+				if (nc->accum_pass != accum_pass) {
+					ERR_CONTINUE(cache_update_size >= NODE_CACHE_UPDATE_MAX);
+					nc->accum_pass = accum_pass;
+					cache_update[cache_update_size++] = nc;
+					nc->blend_shape_accum = blend;
+				} else {
+					nc->blend_shape_accum = Math::lerp(nc->blend_shape_accum, blend, p_interp);
+				}
+#endif // _3D_DISABLED
+			} break;
 			case Animation::TYPE_VALUE: {
 				if (!nc->node) {
 					continue;
@@ -947,6 +997,8 @@ void AnimationPlayer::_animation_update_transforms() {
 					nc->skeleton->set_bone_pose_scale(nc->bone_idx, nc->scale_accum);
 				}
 
+			} else if (nc->node_blend_shape) {
+				nc->node_blend_shape->set_blend_shape_value(nc->blend_shape_idx, nc->blend_shape_accum);
 			} else if (nc->node_3d) {
 				if (nc->loc_used) {
 					nc->node_3d->set_position(nc->loc_accum);
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index f8e72a67b6..21e309efe0 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -32,6 +32,7 @@
 #define ANIMATION_PLAYER_H
 
 #include "scene/2d/node_2d.h"
+#include "scene/3d/mesh_instance_3d.h"
 #include "scene/3d/node_3d.h"
 #include "scene/3d/skeleton_3d.h"
 #include "scene/resources/animation.h"
@@ -99,6 +100,8 @@ private:
 #ifndef _3D_DISABLED
 		Node3D *node_3d = nullptr;
 		Skeleton3D *skeleton = nullptr;
+		MeshInstance3D *node_blend_shape = nullptr;
+		int blend_shape_idx = -1;
 #endif // _3D_DISABLED
 		int bone_idx = -1;
 		// accumulated transforms
@@ -110,6 +113,7 @@ private:
 		Vector3 loc_accum;
 		Quaternion rot_accum;
 		Vector3 scale_accum;
+		float blend_shape_accum = 0;
 		uint64_t accum_pass = 0;
 
 		bool audio_playing = false;
@@ -147,10 +151,15 @@ private:
 	struct TrackNodeCacheKey {
 		ObjectID id;
 		int bone_idx = -1;
+		int blend_shape_idx = -1;
 
 		inline bool operator<(const TrackNodeCacheKey &p_right) const {
 			if (id == p_right.id) {
-				return bone_idx < p_right.bone_idx;
+				if (blend_shape_idx == p_right.blend_shape_idx) {
+					return bone_idx < p_right.bone_idx;
+				} else {
+					return blend_shape_idx < p_right.blend_shape_idx;
+				}
 			} else {
 				return id < p_right.id;
 			}
diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index dd5fe46223..ccb5fa9472 100644
--- a/scene/animation/animation_tree.cpp
+++ b/scene/animation/animation_tree.cpp
@@ -640,6 +640,37 @@ bool AnimationTree::_update_caches(AnimationPlayer *player) {
 
 #endif // _3D_DISABLED
 					} break;
+					case Animation::TYPE_BLEND_SHAPE: {
+#ifndef _3D_DISABLED
+
+						if (path.get_subname_count() != 1) {
+							ERR_PRINT("AnimationTree: '" + String(E) + "', blend shape track does not contain a blend shape subname:  '" + String(path) + "'");
+							continue;
+						}
+						MeshInstance3D *mesh_3d = Object::cast_to<MeshInstance3D>(child);
+
+						if (!mesh_3d) {
+							ERR_PRINT("AnimationTree: '" + String(E) + "', blend shape track does not point to MeshInstance3D:  '" + String(path) + "'");
+							continue;
+						}
+
+						StringName blend_shape_name = path.get_subname(0);
+						int blend_shape_idx = mesh_3d->find_blend_shape_by_name(blend_shape_name);
+						if (blend_shape_idx == -1) {
+							ERR_PRINT("AnimationTree: '" + String(E) + "', blend shape track points to a non-existing name:  '" + String(blend_shape_name) + "'");
+							continue;
+						}
+
+						TrackCacheBlendShape *track_bshape = memnew(TrackCacheBlendShape);
+
+						track_bshape->mesh_3d = mesh_3d;
+						track_bshape->shape_index = blend_shape_idx;
+
+						track_bshape->object = mesh_3d;
+						track_bshape->object_id = mesh_3d->get_instance_id();
+						track = track_bshape;
+#endif
+					} break;
 					case Animation::TYPE_METHOD: {
 						TrackCacheMethod *track_method = memnew(TrackCacheMethod);
 
@@ -1089,6 +1120,28 @@ void AnimationTree::_process_graph(real_t p_delta) {
 						}
 #endif // _3D_DISABLED
 					} break;
+					case Animation::TYPE_BLEND_SHAPE: {
+#ifndef _3D_DISABLED
+						TrackCacheBlendShape *t = static_cast<TrackCacheBlendShape *>(track);
+
+						if (t->process_pass != process_pass) {
+							t->process_pass = process_pass;
+							t->value = 0;
+						}
+
+						float value;
+
+						Error err = a->blend_shape_track_interpolate(i, time, &value);
+						//ERR_CONTINUE(err!=OK); //used for testing, should be removed
+
+						if (err != OK) {
+							continue;
+						}
+
+						t->value = Math::lerp(t->value, value, blend);
+
+#endif // _3D_DISABLED
+					} break;
 					case Animation::TYPE_VALUE: {
 						TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
 
@@ -1384,6 +1437,15 @@ void AnimationTree::_process_graph(real_t p_delta) {
 					}
 #endif // _3D_DISABLED
 				} break;
+				case Animation::TYPE_BLEND_SHAPE: {
+#ifndef _3D_DISABLED
+					TrackCacheBlendShape *t = static_cast<TrackCacheBlendShape *>(track);
+
+					if (t->mesh_3d) {
+						t->mesh_3d->set_blend_shape_value(t->shape_index, t->value);
+					}
+#endif // _3D_DISABLED
+				} break;
 				case Animation::TYPE_VALUE: {
 					TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
 
diff --git a/scene/animation/animation_tree.h b/scene/animation/animation_tree.h
index ed207dfe0c..21b49937a7 100644
--- a/scene/animation/animation_tree.h
+++ b/scene/animation/animation_tree.h
@@ -210,6 +210,13 @@ private:
 		}
 	};
 
+	struct TrackCacheBlendShape : public TrackCache {
+		MeshInstance3D *mesh_3d = nullptr;
+		float value = 0;
+		int shape_index = -1;
+		TrackCacheBlendShape() { type = Animation::TYPE_BLEND_SHAPE; }
+	};
+
 	struct TrackCacheValue : public TrackCache {
 		Variant value;
 		Vector<StringName> subpath;
diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp
index 6612c5ff3c..08b78a39b1 100644
--- a/scene/resources/animation.cpp
+++ b/scene/resources/animation.cpp
@@ -49,6 +49,8 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 				add_track(TYPE_ROTATION_3D);
 			} else if (type == "scale_3d") {
 				add_track(TYPE_SCALE_3D);
+			} else if (type == "blend_shape") {
+				add_track(TYPE_BLEND_SHAPE);
 			} else if (type == "value") {
 				add_track(TYPE_VALUE);
 			} else if (type == "method") {
@@ -146,6 +148,25 @@ bool Animation::_set(const StringName &p_name, const Variant &p_value) {
 					sk.value.y = ofs[3];
 					sk.value.z = ofs[4];
 				}
+			} else if (track_get_type(track) == TYPE_BLEND_SHAPE) {
+				BlendShapeTrack *st = static_cast<BlendShapeTrack *>(tracks[track]);
+				Vector<real_t> values = p_value;
+				int vcount = values.size();
+				ERR_FAIL_COND_V(vcount % BLEND_SHAPE_TRACK_SIZE, false);
+
+				const real_t *r = values.ptr();
+
+				int64_t count = vcount / BLEND_SHAPE_TRACK_SIZE;
+				st->blend_shapes.resize(count);
+
+				TKey<float> *sw = st->blend_shapes.ptrw();
+				for (int i = 0; i < count; i++) {
+					TKey<float> &sk = sw[i];
+					const real_t *ofs = &r[i * BLEND_SHAPE_TRACK_SIZE];
+					sk.time = ofs[0];
+					sk.transition = ofs[1];
+					sk.value = ofs[2];
+				}
 
 			} else if (track_get_type(track) == TYPE_VALUE) {
 				ValueTrack *vt = static_cast<ValueTrack *>(tracks[track]);
@@ -369,6 +390,9 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 				case TYPE_SCALE_3D:
 					r_ret = "scale_3d";
 					break;
+				case TYPE_BLEND_SHAPE:
+					r_ret = "blend_shape";
+					break;
 				case TYPE_VALUE:
 					r_ret = "value";
 					break;
@@ -464,6 +488,25 @@ bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
 
 				r_ret = keys;
 				return true;
+			} else if (track_get_type(track) == TYPE_BLEND_SHAPE) {
+				Vector<real_t> keys;
+				int kk = track_get_key_count(track);
+				keys.resize(kk * BLEND_SHAPE_TRACK_SIZE);
+
+				real_t *w = keys.ptrw();
+
+				int idx = 0;
+				for (int i = 0; i < track_get_key_count(track); i++) {
+					float bs;
+					blend_shape_track_get_key(track, i, &bs);
+
+					w[idx++] = track_get_key_time(track, i);
+					w[idx++] = track_get_key_transition(track, i);
+					w[idx++] = bs;
+				}
+
+				r_ret = keys;
+				return true;
 			} else if (track_get_type(track) == TYPE_VALUE) {
 				const ValueTrack *vt = static_cast<const ValueTrack *>(tracks[track]);
 
@@ -682,6 +725,10 @@ int Animation::add_track(TrackType p_type, int p_at_pos) {
 			ScaleTrack *st = memnew(ScaleTrack);
 			tracks.insert(p_at_pos, st);
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = memnew(BlendShapeTrack);
+			tracks.insert(p_at_pos, bst);
+		} break;
 		case TYPE_VALUE: {
 			tracks.insert(p_at_pos, memnew(ValueTrack));
 
@@ -731,6 +778,11 @@ void Animation::remove_track(int p_track) {
 			_clear(st->scales);
 
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			_clear(bst->blend_shapes);
+
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			_clear(vt->values);
@@ -993,6 +1045,53 @@ Error Animation::scale_track_interpolate(int p_track, double p_time, Vector3 *r_
 	return OK;
 }
 
+int Animation::blend_shape_track_insert_key(int p_track, double p_time, float p_blend_shape) {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_BLEND_SHAPE, -1);
+
+	BlendShapeTrack *st = static_cast<BlendShapeTrack *>(t);
+
+	TKey<float> tkey;
+	tkey.time = p_time;
+	tkey.value = p_blend_shape;
+
+	int ret = _insert(p_time, st->blend_shapes, tkey);
+	emit_changed();
+	return ret;
+}
+
+Error Animation::blend_shape_track_get_key(int p_track, int p_key, float *r_blend_shape) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+
+	BlendShapeTrack *st = static_cast<BlendShapeTrack *>(t);
+	ERR_FAIL_COND_V(t->type != TYPE_BLEND_SHAPE, ERR_INVALID_PARAMETER);
+	ERR_FAIL_INDEX_V(p_key, st->blend_shapes.size(), ERR_INVALID_PARAMETER);
+
+	*r_blend_shape = st->blend_shapes[p_key].value;
+
+	return OK;
+}
+
+Error Animation::blend_shape_track_interpolate(int p_track, double p_time, float *r_interpolation) const {
+	ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
+	Track *t = tracks[p_track];
+	ERR_FAIL_COND_V(t->type != TYPE_BLEND_SHAPE, ERR_INVALID_PARAMETER);
+
+	BlendShapeTrack *st = static_cast<BlendShapeTrack *>(t);
+
+	bool ok = false;
+
+	float tk = _interpolate(st->blend_shapes, p_time, st->interpolation, st->loop_wrap, &ok);
+
+	if (!ok) {
+		return ERR_UNAVAILABLE;
+	}
+	*r_interpolation = tk;
+	return OK;
+}
+
 void Animation::track_remove_key_at_time(int p_track, double p_time) {
 	int idx = track_find_key(p_track, p_time, true);
 	ERR_FAIL_COND(idx < 0);
@@ -1022,6 +1121,12 @@ void Animation::track_remove_key(int p_track, int p_idx) {
 			st->scales.remove(p_idx);
 
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX(p_idx, bst->blend_shapes.size());
+			bst->blend_shapes.remove(p_idx);
+
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_idx, vt->values.size());
@@ -1087,12 +1192,24 @@ int Animation::track_find_key(int p_track, double p_time, bool p_exact) const {
 
 		} break;
 		case TYPE_SCALE_3D: {
-			ScaleTrack *rt = static_cast<ScaleTrack *>(t);
-			int k = _find(rt->scales, p_time);
-			if (k < 0 || k >= rt->scales.size()) {
+			ScaleTrack *st = static_cast<ScaleTrack *>(t);
+			int k = _find(st->scales, p_time);
+			if (k < 0 || k >= st->scales.size()) {
+				return -1;
+			}
+			if (st->scales[k].time != p_time && p_exact) {
+				return -1;
+			}
+			return k;
+
+		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			int k = _find(bst->blend_shapes, p_time);
+			if (k < 0 || k >= bst->blend_shapes.size()) {
 				return -1;
 			}
-			if (rt->scales[k].time != p_time && p_exact) {
+			if (bst->blend_shapes[k].time != p_time && p_exact) {
 				return -1;
 			}
 			return k;
@@ -1186,6 +1303,12 @@ void Animation::track_insert_key(int p_track, double p_time, const Variant &p_ke
 			track_set_key_transition(p_track, idx, p_transition);
 
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			ERR_FAIL_COND((p_key.get_type() != Variant::FLOAT) && (p_key.get_type() != Variant::INT));
+			int idx = blend_shape_track_insert_key(p_track, p_time, p_key);
+			track_set_key_transition(p_track, idx, p_transition);
+
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 
@@ -1279,6 +1402,10 @@ int Animation::track_get_key_count(int p_track) const {
 			ScaleTrack *st = static_cast<ScaleTrack *>(t);
 			return st->scales.size();
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			return bst->blend_shapes.size();
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			return vt->values.size();
@@ -1328,6 +1455,12 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
 
 			return st->scales[p_key_idx].value;
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, bst->blend_shapes.size(), Variant());
+
+			return bst->blend_shapes[p_key_idx].value;
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), Variant());
@@ -1400,6 +1533,11 @@ double Animation::track_get_key_time(int p_track, int p_key_idx) const {
 			ERR_FAIL_INDEX_V(p_key_idx, st->scales.size(), -1);
 			return st->scales[p_key_idx].time;
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, bst->blend_shapes.size(), -1);
+			return bst->blend_shapes[p_key_idx].time;
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
@@ -1467,6 +1605,15 @@ void Animation::track_set_key_time(int p_track, int p_key_idx, double p_time) {
 			_insert(p_time, tt->scales, key);
 			return;
 		}
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *tt = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, tt->blend_shapes.size());
+			TKey<float> key = tt->blend_shapes[p_key_idx];
+			key.time = p_time;
+			tt->blend_shapes.remove(p_key_idx);
+			_insert(p_time, tt->blend_shapes, key);
+			return;
+		}
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
@@ -1537,6 +1684,11 @@ real_t Animation::track_get_key_transition(int p_track, int p_key_idx) const {
 			ERR_FAIL_INDEX_V(p_key_idx, st->scales.size(), -1);
 			return st->scales[p_key_idx].transition;
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX_V(p_key_idx, bst->blend_shapes.size(), -1);
+			return bst->blend_shapes[p_key_idx].transition;
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
@@ -1592,6 +1744,14 @@ void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p
 			st->scales.write[p_key_idx].value = p_value;
 
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			ERR_FAIL_COND((p_value.get_type() != Variant::FLOAT) && (p_value.get_type() != Variant::INT));
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, bst->blend_shapes.size());
+
+			bst->blend_shapes.write[p_key_idx].value = p_value;
+
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
@@ -1673,6 +1833,11 @@ void Animation::track_set_key_transition(int p_track, int p_key_idx, real_t p_tr
 			ERR_FAIL_INDEX(p_key_idx, st->scales.size());
 			st->scales.write[p_key_idx].transition = p_transition;
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			BlendShapeTrack *bst = static_cast<BlendShapeTrack *>(t);
+			ERR_FAIL_INDEX(p_key_idx, bst->blend_shapes.size());
+			bst->blend_shapes.write[p_key_idx].transition = p_transition;
+		} break;
 		case TYPE_VALUE: {
 			ValueTrack *vt = static_cast<ValueTrack *>(t);
 			ERR_FAIL_INDEX(p_key_idx, vt->values.size());
@@ -2185,6 +2350,12 @@ void Animation::track_get_key_indices_in_range(int p_track, double p_time, doubl
 					_track_get_key_indices_in_range(st->scales, 0, to_time, p_indices);
 
 				} break;
+				case TYPE_BLEND_SHAPE: {
+					const BlendShapeTrack *bst = static_cast<const BlendShapeTrack *>(t);
+					_track_get_key_indices_in_range(bst->blend_shapes, from_time, length, p_indices);
+					_track_get_key_indices_in_range(bst->blend_shapes, 0, to_time, p_indices);
+
+				} break;
 				case TYPE_VALUE: {
 					const ValueTrack *vt = static_cast<const ValueTrack *>(t);
 					_track_get_key_indices_in_range(vt->values, from_time, length, p_indices);
@@ -2250,6 +2421,11 @@ void Animation::track_get_key_indices_in_range(int p_track, double p_time, doubl
 			_track_get_key_indices_in_range(st->scales, from_time, to_time, p_indices);
 
 		} break;
+		case TYPE_BLEND_SHAPE: {
+			const BlendShapeTrack *bst = static_cast<const BlendShapeTrack *>(t);
+			_track_get_key_indices_in_range(bst->blend_shapes, from_time, to_time, p_indices);
+
+		} break;
 		case TYPE_VALUE: {
 			const ValueTrack *vt = static_cast<const ValueTrack *>(t);
 			_track_get_key_indices_in_range(vt->values, from_time, to_time, p_indices);
@@ -2867,6 +3043,7 @@ void Animation::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("position_track_insert_key", "track_idx", "time", "position"), &Animation::position_track_insert_key);
 	ClassDB::bind_method(D_METHOD("rotation_track_insert_key", "track_idx", "time", "rotation"), &Animation::rotation_track_insert_key);
 	ClassDB::bind_method(D_METHOD("scale_track_insert_key", "track_idx", "time", "scale"), &Animation::scale_track_insert_key);
+	ClassDB::bind_method(D_METHOD("blend_shape_track_insert_key", "track_idx", "time", "amount"), &Animation::blend_shape_track_insert_key);
 
 	ClassDB::bind_method(D_METHOD("track_insert_key", "track_idx", "time", "key", "transition"), &Animation::track_insert_key, DEFVAL(1));
 	ClassDB::bind_method(D_METHOD("track_remove_key", "track_idx", "key_idx"), &Animation::track_remove_key);
@@ -2943,6 +3120,7 @@ void Animation::_bind_methods() {
 	BIND_ENUM_CONSTANT(TYPE_POSITION_3D);
 	BIND_ENUM_CONSTANT(TYPE_ROTATION_3D);
 	BIND_ENUM_CONSTANT(TYPE_SCALE_3D);
+	BIND_ENUM_CONSTANT(TYPE_BLEND_SHAPE);
 	BIND_ENUM_CONSTANT(TYPE_METHOD);
 	BIND_ENUM_CONSTANT(TYPE_BEZIER);
 	BIND_ENUM_CONSTANT(TYPE_AUDIO);
@@ -3089,6 +3267,41 @@ bool Animation::_scale_track_optimize_key(const TKey<Vector3> &t0, const TKey<Ve
 	return true;
 }
 
+bool Animation::_blend_shape_track_optimize_key(const TKey<float> &t0, const TKey<float> &t1, const TKey<float> &t2, real_t p_allowed_unit_error) {
+	float v0 = t0.value;
+	float v1 = t1.value;
+	float v2 = t2.value;
+
+	if (Math::is_equal_approx(v1, v2, p_allowed_unit_error)) {
+		//0 and 2 are close, let's see if 1 is close
+		if (!Math::is_equal_approx(v0, v1, p_allowed_unit_error)) {
+			//not close, not optimizable
+			return false;
+		}
+
+	} else {
+		/*
+		TODO eventually discuss a way to optimize these better.
+		float pd = (v2 - v0);
+		real_t d0 = pd.dot(v0);
+		real_t d1 = pd.dot(v1);
+		real_t d2 = pd.dot(v2);
+		if (d1 < d0 || d1 > d2) {
+			return false; //beyond segment range
+		}
+
+		float s[2] = { v0, v2 };
+		real_t d = Geometry3D::get_closest_point_to_segment(v1, s).distance_to(v1);
+
+		if (d > pd.length() * p_allowed_linear_error) {
+			return false; //beyond allowed error for colinearity
+		}
+*/
+	}
+
+	return true;
+}
+
 void Animation::_position_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err) {
 	ERR_FAIL_INDEX(p_idx, tracks.size());
 	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_POSITION_3D);
@@ -3197,6 +3410,41 @@ void Animation::_scale_track_optimize(int p_idx, real_t p_allowed_linear_err) {
 	}
 }
 
+void Animation::_blend_shape_track_optimize(int p_idx, real_t p_allowed_linear_err) {
+	ERR_FAIL_INDEX(p_idx, tracks.size());
+	ERR_FAIL_COND(tracks[p_idx]->type != TYPE_BLEND_SHAPE);
+	BlendShapeTrack *tt = static_cast<BlendShapeTrack *>(tracks[p_idx]);
+	bool prev_erased = false;
+	TKey<float> first_erased;
+	first_erased.value = 0.0;
+
+	for (int i = 1; i < tt->blend_shapes.size() - 1; i++) {
+		TKey<float> &t0 = tt->blend_shapes.write[i - 1];
+		TKey<float> &t1 = tt->blend_shapes.write[i];
+		TKey<float> &t2 = tt->blend_shapes.write[i + 1];
+
+		bool erase = _blend_shape_track_optimize_key(t0, t1, t2, p_allowed_linear_err);
+
+		if (prev_erased && !_blend_shape_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err)) {
+			//avoid error to go beyond first erased key
+			erase = false;
+		}
+
+		if (erase) {
+			if (!prev_erased) {
+				first_erased = t1;
+				prev_erased = true;
+			}
+
+			tt->blend_shapes.remove(i);
+			i--;
+
+		} else {
+			prev_erased = false;
+		}
+	}
+}
+
 void Animation::optimize(real_t p_allowed_linear_err, real_t p_allowed_angular_err, real_t p_max_optimizable_angle) {
 	for (int i = 0; i < tracks.size(); i++) {
 		if (tracks[i]->type == TYPE_POSITION_3D) {
@@ -3205,6 +3453,8 @@ void Animation::optimize(real_t p_allowed_linear_err, real_t p_allowed_angular_e
 			_rotation_track_optimize(i, p_allowed_angular_err, p_max_optimizable_angle);
 		} else if (tracks[i]->type == TYPE_SCALE_3D) {
 			_scale_track_optimize(i, p_allowed_linear_err);
+		} else if (tracks[i]->type == TYPE_BLEND_SHAPE) {
+			_blend_shape_track_optimize(i, p_allowed_linear_err);
 		}
 	}
 }
diff --git a/scene/resources/animation.h b/scene/resources/animation.h
index 614e12a560..4ee0741d87 100644
--- a/scene/resources/animation.h
+++ b/scene/resources/animation.h
@@ -45,6 +45,7 @@ public:
 		TYPE_POSITION_3D, ///< Position 3D track
 		TYPE_ROTATION_3D, ///< Rotation 3D track
 		TYPE_SCALE_3D, ///< Scale 3D track
+		TYPE_BLEND_SHAPE, ///< Blend Shape track
 		TYPE_METHOD, ///< Call any method on a specific node.
 		TYPE_BEZIER, ///< Bezier curve
 		TYPE_AUDIO,
@@ -91,6 +92,7 @@ private:
 	const int32_t POSITION_TRACK_SIZE = 5;
 	const int32_t ROTATION_TRACK_SIZE = 6;
 	const int32_t SCALE_TRACK_SIZE = 5;
+	const int32_t BLEND_SHAPE_TRACK_SIZE = 3;
 
 	/* POSITION TRACK */
 
@@ -115,6 +117,13 @@ private:
 		ScaleTrack() { type = TYPE_SCALE_3D; }
 	};
 
+	/* BLEND SHAPE TRACK */
+
+	struct BlendShapeTrack : public Track {
+		Vector<TKey<float>> blend_shapes;
+		BlendShapeTrack() { type = TYPE_BLEND_SHAPE; }
+	};
+
 	/* PROPERTY VALUE TRACK */
 
 	struct ValueTrack : public Track {
@@ -247,10 +256,12 @@ private:
 	bool _position_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_alowed_linear_err, real_t p_allowed_angular_error, const Vector3 &p_norm);
 	bool _rotation_track_optimize_key(const TKey<Quaternion> &t0, const TKey<Quaternion> &t1, const TKey<Quaternion> &t2, real_t p_allowed_angular_error, float p_max_optimizable_angle);
 	bool _scale_track_optimize_key(const TKey<Vector3> &t0, const TKey<Vector3> &t1, const TKey<Vector3> &t2, real_t p_allowed_linear_error);
+	bool _blend_shape_track_optimize_key(const TKey<float> &t0, const TKey<float> &t1, const TKey<float> &t2, real_t p_allowed_unit_error);
 
 	void _position_track_optimize(int p_idx, real_t p_allowed_linear_err, real_t p_allowed_angular_err);
 	void _rotation_track_optimize(int p_idx, real_t p_allowed_angular_err, real_t p_max_optimizable_angle);
 	void _scale_track_optimize(int p_idx, real_t p_allowed_linear_err);
+	void _blend_shape_track_optimize(int p_idx, real_t p_allowed_unit_error);
 
 protected:
 	bool _set(const StringName &p_name, const Variant &p_value);
@@ -308,6 +319,10 @@ public:
 	Error scale_track_get_key(int p_track, int p_key, Vector3 *r_scale) const;
 	Error scale_track_interpolate(int p_track, double p_time, Vector3 *r_interpolation) const;
 
+	int blend_shape_track_insert_key(int p_track, double p_time, float p_blend);
+	Error blend_shape_track_get_key(int p_track, int p_key, float *r_blend) const;
+	Error blend_shape_track_interpolate(int p_track, double p_time, float *r_blend) const;
+
 	void track_set_interpolation_type(int p_track, InterpolationType p_interp);
 	InterpolationType track_get_interpolation_type(int p_track) const;