Entirely new (and much improved) animation editor.

1 files changed, 1289 insertions, 0 deletions

diff --git a/editor/animation_track_editor_plugins.cpp b/editor/animation_track_editor_plugins.cpp
new file mode 100644
index 0000000000..660c69f4a4
--- /dev/null
+++ b/editor/animation_track_editor_plugins.cpp
@@ -0,0 +1,1289 @@
+#include "animation_track_editor_plugins.h"
+#include "editor/audio_stream_preview.h"
+#include "editor_resource_preview.h"
+#include "editor_scale.h"
+#include "scene/2d/animated_sprite.h"
+#include "scene/2d/sprite.h"
+#include "scene/3d/sprite_3d.h"
+#include "scene/animation/animation_player.h"
+#include "servers/audio/audio_stream.h"
+/// BOOL ///
+int AnimationTrackEditBool::get_key_height() const {
+
+	Ref<Texture> checked = get_icon("checked", "CheckBox");
+	return checked->get_height();
+}
+Rect2 AnimationTrackEditBool::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Ref<Texture> checked = get_icon("checked", "CheckBox");
+	return Rect2(0, 0, checked->get_width(), get_size().height);
+}
+
+bool AnimationTrackEditBool::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditBool::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Ref<Texture> icon;
+	bool checked = get_animation()->track_get_key_value(get_track(), p_index);
+
+	if (checked)
+		icon = get_icon("checked", "CheckBox");
+	else
+		icon = get_icon("unchecked", "CheckBox");
+
+	Vector2 ofs(p_x, int(get_size().height - icon->get_height()) / 2);
+
+	draw_texture_clipped(icon, ofs);
+
+	if (p_selected) {
+		Color color = get_color("accent_color", "Editor");
+		draw_rect_clipped(Rect2(ofs, icon->get_size()), color, false);
+	}
+}
+
+/// COLOR ///
+
+int AnimationTrackEditColor::get_key_height() const {
+
+	Ref<Font> font = get_font("font", "Label");
+	return font->get_height() * 0.8;
+}
+Rect2 AnimationTrackEditColor::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Ref<Font> font = get_font("font", "Label");
+	int fh = font->get_height() * 0.8;
+	return Rect2(0, 0, fh, get_size().height);
+}
+
+bool AnimationTrackEditColor::is_key_selectable_by_distance() const {
+
+	return false;
+}
+
+void AnimationTrackEditColor::draw_key_link(int p_index, float p_pixels_sec, int p_x, int p_next_x, int p_clip_left, int p_clip_right) {
+
+	int x_from = p_x;
+	int x_to = p_next_x;
+
+	Ref<Font> font = get_font("font", "Label");
+	int fh = (font->get_height() * 0.8);
+
+	x_from += fh - 1;
+	x_to += 1;
+	fh /= 3;
+
+	if (x_from > p_clip_right)
+		return;
+
+	if (x_to < p_clip_left)
+		return;
+
+	Color color = get_animation()->track_get_key_value(get_track(), p_index);
+	Color color_next = get_animation()->track_get_key_value(get_track(), p_index + 1);
+
+	if (x_from < p_clip_left) {
+		float c = float(p_clip_left - x_from) / (x_to - x_from);
+		color = color.linear_interpolate(color_next, c);
+		x_from = p_clip_left;
+	}
+
+	if (x_to > p_clip_right) {
+		float c = float(p_clip_right - x_from) / (x_to - x_from);
+		color_next = color.linear_interpolate(color_next, c);
+		x_to = p_clip_right;
+	}
+
+	int y_from = (get_size().height - fh) / 2;
+
+	Vector<Vector2> points;
+	Vector<Color> colors;
+
+	points.push_back(Vector2(x_from, y_from));
+	colors.push_back(color);
+
+	points.push_back(Vector2(x_to, y_from));
+	colors.push_back(color_next);
+
+	points.push_back(Vector2(x_to, y_from + fh));
+	colors.push_back(color_next);
+
+	points.push_back(Vector2(x_from, y_from + fh));
+	colors.push_back(color);
+
+	draw_primitive(points, colors, Vector<Vector2>());
+}
+
+void AnimationTrackEditColor::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Color color = get_animation()->track_get_key_value(get_track(), p_index);
+
+	Ref<Font> font = get_font("font", "Label");
+	int fh = font->get_height() * 0.8;
+
+	Rect2 rect(Vector2(p_x, int(get_size().height - fh) / 2), Size2(fh, fh));
+
+	draw_rect_clipped(Rect2(rect.position, rect.size / 2), Color(0.4, 0.4, 0.4));
+	draw_rect_clipped(Rect2(rect.position + rect.size / 2, rect.size / 2), Color(0.4, 0.4, 0.4));
+	draw_rect_clipped(Rect2(rect.position + Vector2(rect.size.x / 2, 0), rect.size / 2), Color(0.6, 0.6, 0.6));
+	draw_rect_clipped(Rect2(rect.position + Vector2(0, rect.size.y / 2), rect.size / 2), Color(0.6, 0.6, 0.6));
+	draw_rect_clipped(rect, color);
+
+	if (p_selected) {
+		Color accent = get_color("accent_color", "Editor");
+		draw_rect_clipped(rect, accent, false);
+	}
+}
+
+/// AUDIO ///
+
+void AnimationTrackEditAudio::_preview_changed(ObjectID p_which) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object)
+		return;
+
+	Ref<AudioStream> stream = object->call("get_stream");
+
+	if (stream.is_valid() && stream->get_instance_id() == p_which) {
+		update();
+	}
+}
+
+int AnimationTrackEditAudio::get_key_height() const {
+
+	if (!ObjectDB::get_instance(id)) {
+		return AnimationTrackEdit::get_key_height();
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	return int(font->get_height() * 1.5);
+}
+Rect2 AnimationTrackEditAudio::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	Ref<AudioStream> stream = object->call("get_stream");
+
+	if (!stream.is_valid()) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	bool play = get_animation()->track_get_key_value(get_track(), p_index);
+	if (play) {
+		float len = stream->get_length();
+
+		if (len == 0) {
+
+			Ref<AudioStreamPreview> preview = AudioStreamPreviewGenerator::get_singleton()->generate_preview(stream);
+			len = preview->get_length();
+		}
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		}
+
+		return Rect2(0, 0, len * p_pixels_sec, get_size().height);
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		return Rect2(0, 0, fh, get_size().height);
+	}
+}
+
+bool AnimationTrackEditAudio::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditAudio::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	Ref<AudioStream> stream = object->call("get_stream");
+
+	if (!stream.is_valid()) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	float fh = int(font->get_height() * 1.5);
+
+	bool play = get_animation()->track_get_key_value(get_track(), p_index);
+	if (play) {
+		float len = stream->get_length();
+
+		Ref<AudioStreamPreview> preview = AudioStreamPreviewGenerator::get_singleton()->generate_preview(stream);
+
+		float preview_len = preview->get_length();
+
+		if (len == 0) {
+			len = preview_len;
+		}
+
+		int pixel_len = len * p_pixels_sec;
+
+		int pixel_begin = p_x;
+		int pixel_end = p_x + pixel_len;
+
+		if (pixel_end < p_clip_left)
+			return;
+
+		if (pixel_begin > p_clip_right)
+			return;
+
+		int from_x = MAX(pixel_begin, p_clip_left);
+		int to_x = MIN(pixel_end, p_clip_right);
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			float limit = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+			int limit_x = pixel_begin + limit * p_pixels_sec;
+			to_x = MIN(limit_x, to_x);
+		}
+
+		if (to_x <= from_x)
+			return;
+
+		int h = get_size().height;
+		Rect2 rect = Rect2(from_x, (h - fh) / 2, to_x - from_x, fh);
+		draw_rect(rect, Color(0.25, 0.25, 0.25));
+
+		Vector<Vector2> lines;
+		lines.resize((to_x - from_x + 1) * 2);
+		preview_len = preview->get_length();
+
+		for (int i = from_x; i < to_x; i++) {
+
+			float ofs = (i - pixel_begin) * preview_len / pixel_len;
+			float ofs_n = ((i + 1) - pixel_begin) * preview_len / pixel_len;
+			float max = preview->get_max(ofs, ofs_n) * 0.5 + 0.5;
+			float min = preview->get_min(ofs, ofs_n) * 0.5 + 0.5;
+
+			int idx = i - from_x;
+			lines[idx * 2 + 0] = Vector2(i, rect.position.y + min * rect.size.y);
+			lines[idx * 2 + 1] = Vector2(i, rect.position.y + max * rect.size.y);
+		}
+
+		Vector<Color> color;
+		color.push_back(Color(0.75, 0.75, 0.75));
+
+		VS::get_singleton()->canvas_item_add_multiline(get_canvas_item(), lines, color);
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		Rect2 rect(Vector2(p_x, int(get_size().height - fh) / 2), Size2(fh, fh));
+
+		Color color = get_color("font_color", "Label");
+		draw_rect(rect, color);
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	}
+}
+
+void AnimationTrackEditAudio::set_node(Object *p_object) {
+
+	id = p_object->get_instance_id();
+}
+
+void AnimationTrackEditAudio::_bind_methods() {
+	ClassDB::bind_method("_preview_changed", &AnimationTrackEditAudio::_preview_changed);
+}
+
+AnimationTrackEditAudio::AnimationTrackEditAudio() {
+	AudioStreamPreviewGenerator::get_singleton()->connect("preview_updated", this, "_preview_changed");
+}
+
+/// SPRITE FRAME ///
+
+int AnimationTrackEditSpriteFrame::get_key_height() const {
+
+	if (!ObjectDB::get_instance(id)) {
+		return AnimationTrackEdit::get_key_height();
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	return int(font->get_height() * 2);
+}
+Rect2 AnimationTrackEditSpriteFrame::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	Size2 size;
+
+	if (Object::cast_to<Sprite>(object) || Object::cast_to<Sprite3D>(object)) {
+
+		Ref<Texture> texture = object->call("get_texture");
+		if (!texture.is_valid()) {
+			return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+		}
+
+		size = texture->get_size();
+
+		if (bool(object->call("is_region"))) {
+			size = Rect2(object->call("get_region_rect")).size;
+		}
+
+		int hframes = object->call("get_hframes");
+		int vframes = object->call("get_vframes");
+
+		if (hframes > 1) {
+			size.x /= hframes;
+		}
+		if (vframes > 1) {
+			size.y /= vframes;
+		}
+	} else if (Object::cast_to<AnimatedSprite>(object) || Object::cast_to<AnimatedSprite3D>(object)) {
+
+		int frame = get_animation()->track_get_key_value(get_track(), p_index);
+		String animation = "default"; //may be smart and go through other tracks to find if animation is set
+
+		Ref<SpriteFrames> sf = object->call("get_sprite_frames");
+		if (sf.is_null()) {
+			return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+		}
+
+		Ref<Texture> texture = sf->get_frame(animation, frame);
+		if (!texture.is_valid()) {
+			return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+		}
+
+		size = texture->get_size();
+	}
+
+	size = size.floor();
+
+	Ref<Font> font = get_font("font", "Label");
+	int height = int(font->get_height() * 2);
+	int width = height * size.width / size.height;
+
+	return Rect2(0, 0, width, get_size().height);
+}
+
+bool AnimationTrackEditSpriteFrame::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditSpriteFrame::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	int frame = get_animation()->track_get_key_value(get_track(), p_index);
+
+	Ref<Texture> texture;
+	Rect2 region;
+
+	if (Object::cast_to<Sprite>(object) || Object::cast_to<Sprite3D>(object)) {
+
+		texture = object->call("get_texture");
+		if (!texture.is_valid()) {
+			AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+			return;
+		}
+
+		region.size = texture->get_size();
+
+		if (bool(object->call("is_region"))) {
+
+			region = Rect2(object->call("get_region_rect"));
+		}
+
+		int hframes = object->call("get_hframes");
+		int vframes = object->call("get_vframes");
+
+		if (hframes > 1) {
+			region.size.x /= hframes;
+		}
+		if (vframes > 1) {
+			region.size.y /= vframes;
+		}
+
+		region.position.x += region.size.x * (frame % hframes);
+		region.position.y += region.size.y * (frame / hframes);
+
+	} else if (Object::cast_to<AnimatedSprite>(object) || Object::cast_to<AnimatedSprite3D>(object)) {
+
+		int frame = get_animation()->track_get_key_value(get_track(), p_index);
+		String animation = "default"; //may be smart and go through other tracks to find if animation is set
+
+		Ref<SpriteFrames> sf = object->call("get_sprite_frames");
+		if (sf.is_null()) {
+			AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+			return;
+		}
+
+		texture = sf->get_frame(animation, frame);
+		if (!texture.is_valid()) {
+			AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+			return;
+		}
+
+		region.size = texture->get_size();
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	int height = int(font->get_height() * 2);
+
+	int width = height * region.size.width / region.size.height;
+
+	Rect2 rect(p_x, int(get_size().height - height) / 2, width, height);
+
+	if (rect.position.x + rect.size.x < p_clip_left)
+		return;
+
+	if (rect.position.x > p_clip_right)
+		return;
+
+	Color accent = get_color("accent_color", "Editor");
+	Color bg = accent;
+	bg.a = 0.15;
+
+	draw_rect_clipped(rect, bg);
+
+	draw_texture_region_clipped(texture, rect, region);
+
+	if (p_selected) {
+		draw_rect_clipped(rect, accent, false);
+	}
+}
+
+void AnimationTrackEditSpriteFrame::set_node(Object *p_object) {
+
+	id = p_object->get_instance_id();
+}
+
+/// SUB ANIMATION ///
+
+int AnimationTrackEditSubAnim::get_key_height() const {
+
+	if (!ObjectDB::get_instance(id)) {
+		return AnimationTrackEdit::get_key_height();
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	return int(font->get_height() * 1.5);
+}
+Rect2 AnimationTrackEditSubAnim::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(object);
+
+	if (!ap) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	String anim = get_animation()->track_get_key_value(get_track(), p_index);
+
+	if (anim != "[stop]" && ap->has_animation(anim)) {
+
+		float len = ap->get_animation(anim)->get_length();
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		}
+
+		return Rect2(0, 0, len * p_pixels_sec, get_size().height);
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		return Rect2(0, 0, fh, get_size().height);
+	}
+}
+
+bool AnimationTrackEditSubAnim::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditSubAnim::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(object);
+
+	if (!ap) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	String anim = get_animation()->track_get_key_value(get_track(), p_index);
+
+	if (anim != "[stop]" && ap->has_animation(anim)) {
+
+		float len = ap->get_animation(anim)->get_length();
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		}
+
+		int pixel_len = len * p_pixels_sec;
+
+		int pixel_begin = p_x;
+		int pixel_end = p_x + pixel_len;
+
+		if (pixel_end < p_clip_left)
+			return;
+
+		if (pixel_begin > p_clip_right)
+			return;
+
+		int from_x = MAX(pixel_begin, p_clip_left);
+		int to_x = MIN(pixel_end, p_clip_right);
+
+		if (to_x <= from_x)
+			return;
+
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 1.5;
+
+		Rect2 rect(from_x, int(get_size().height - fh) / 2, to_x - from_x, fh);
+
+		Color color = get_color("font_color", "Label");
+		Color bg = color;
+		bg.r = 1 - color.r;
+		bg.g = 1 - color.g;
+		bg.b = 1 - color.b;
+		draw_rect(rect, bg);
+
+		Vector<Vector2> lines;
+		Vector<Color> colorv;
+		{
+			Ref<Animation> animation = ap->get_animation(anim);
+
+			for (int i = 0; i < animation->get_track_count(); i++) {
+
+				float h = (rect.size.height - 2) / animation->get_track_count();
+
+				int y = 2 + h * i + h / 2;
+
+				for (int j = 0; j < animation->track_get_key_count(i); j++) {
+
+					float ofs = animation->track_get_key_time(i, j);
+					int x = p_x + ofs * p_pixels_sec + 2;
+
+					if (x < from_x || x >= (to_x - 4))
+						continue;
+
+					lines.push_back(Point2(x, y));
+					lines.push_back(Point2(x + 1, y));
+				}
+			}
+
+			colorv.push_back(color);
+		}
+
+		if (lines.size() > 2) {
+			VS::get_singleton()->canvas_item_add_multiline(get_canvas_item(), lines, colorv);
+		}
+
+		int limit = to_x - from_x - 4;
+		if (limit > 0) {
+			draw_string(font, Point2(from_x + 2, int(get_size().height - font->get_height()) / 2 + font->get_ascent()), anim, color);
+		}
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		Rect2 rect(Vector2(p_x, int(get_size().height - fh) / 2), Size2(fh, fh));
+
+		Color color = get_color("font_color", "Label");
+		draw_rect(rect, color);
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	}
+}
+
+void AnimationTrackEditSubAnim::set_node(Object *p_object) {
+
+	id = p_object->get_instance_id();
+}
+
+//// VOLUME DB ////
+
+int AnimationTrackEditVolumeDB::get_key_height() const {
+
+	Ref<Texture> volume_texture = get_icon("ColorTrackVu", "EditorIcons");
+	return volume_texture->get_height() * 1.2;
+}
+
+void AnimationTrackEditVolumeDB::draw_bg(int p_clip_left, int p_clip_right) {
+
+	Ref<Texture> volume_texture = get_icon("ColorTrackVu", "EditorIcons");
+	int tex_h = volume_texture->get_height();
+
+	int y_from = (get_size().height - tex_h) / 2;
+	int y_size = tex_h;
+
+	Color color(1, 1, 1, 0.3);
+	draw_texture_rect(volume_texture, Rect2(p_clip_left, y_from, p_clip_right - p_clip_left, y_from + y_size), false, color);
+}
+
+void AnimationTrackEditVolumeDB::draw_fg(int p_clip_left, int p_clip_right) {
+
+	Ref<Texture> volume_texture = get_icon("ColorTrackVu", "EditorIcons");
+	int tex_h = volume_texture->get_height();
+	int y_from = (get_size().height - tex_h) / 2;
+	int db0 = y_from + (24 / 80.0) * tex_h;
+
+	draw_line(Vector2(p_clip_left, db0), Vector2(p_clip_right, db0), Color(1, 1, 1, 0.3));
+}
+
+void AnimationTrackEditVolumeDB::draw_key_link(int p_index, float p_pixels_sec, int p_x, int p_next_x, int p_clip_left, int p_clip_right) {
+
+	if (p_x > p_clip_right || p_next_x < p_clip_left)
+		return;
+
+	float db = get_animation()->track_get_key_value(get_track(), p_index);
+	float db_n = get_animation()->track_get_key_value(get_track(), p_index + 1);
+
+	db = CLAMP(db, -60, 24);
+	db_n = CLAMP(db_n, -60, 24);
+
+	float h = 1.0 - ((db + 60) / 84.0);
+	float h_n = 1.0 - ((db_n + 60) / 84.0);
+
+	int from_x = p_x;
+	int to_x = p_next_x;
+
+	if (from_x < p_clip_left) {
+		h = Math::lerp(h, h_n, float(p_clip_left - from_x) / float(to_x - from_x));
+		from_x = p_clip_left;
+	}
+
+	if (to_x > p_clip_right) {
+		h_n = Math::lerp(h, h_n, float(p_clip_right - from_x) / float(to_x - from_x));
+		to_x = p_clip_right;
+	}
+
+	Ref<Texture> volume_texture = get_icon("ColorTrackVu", "EditorIcons");
+	int tex_h = volume_texture->get_height();
+
+	int y_from = (get_size().height - tex_h) / 2;
+
+	Color color = get_color("font_color", "Label");
+	color.a *= 0.7;
+
+	draw_line(Point2(from_x, y_from + h * tex_h), Point2(to_x, y_from + h_n * tex_h), color, 2);
+}
+
+////////////////////////
+
+/// AUDIO ///
+
+void AnimationTrackEditTypeAudio::_preview_changed(ObjectID p_which) {
+
+	for (int i = 0; i < get_animation()->track_get_key_count(get_track()); i++) {
+		Ref<AudioStream> stream = get_animation()->audio_track_get_key_stream(get_track(), i);
+		if (stream.is_valid() && stream->get_instance_id() == p_which) {
+			update();
+			return;
+		}
+	}
+}
+
+int AnimationTrackEditTypeAudio::get_key_height() const {
+
+	Ref<Font> font = get_font("font", "Label");
+	return int(font->get_height() * 1.5);
+}
+Rect2 AnimationTrackEditTypeAudio::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Ref<AudioStream> stream = get_animation()->audio_track_get_key_stream(get_track(), p_index);
+
+	if (!stream.is_valid()) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	float start_ofs = get_animation()->audio_track_get_key_start_offset(get_track(), p_index);
+	float end_ofs = get_animation()->audio_track_get_key_end_offset(get_track(), p_index);
+
+	float len = stream->get_length();
+
+	if (len == 0) {
+
+		Ref<AudioStreamPreview> preview = AudioStreamPreviewGenerator::get_singleton()->generate_preview(stream);
+		len = preview->get_length();
+	}
+
+	len -= end_ofs;
+	len -= start_ofs;
+	if (len <= 0.001) {
+		len = 0.001;
+	}
+
+	if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+		len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+	}
+
+	return Rect2(0, 0, len * p_pixels_sec, get_size().height);
+}
+
+bool AnimationTrackEditTypeAudio::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditTypeAudio::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Ref<AudioStream> stream = get_animation()->audio_track_get_key_stream(get_track(), p_index);
+
+	if (!stream.is_valid()) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	float start_ofs = get_animation()->audio_track_get_key_start_offset(get_track(), p_index);
+	float end_ofs = get_animation()->audio_track_get_key_end_offset(get_track(), p_index);
+
+	if (len_resizing && p_index == len_resizing_index) {
+		float ofs_local = -len_resizing_rel / get_timeline()->get_zoom_scale();
+		if (len_resizing_start) {
+			start_ofs += ofs_local;
+			if (start_ofs < 0)
+				start_ofs = 0;
+		} else {
+			end_ofs += ofs_local;
+			if (end_ofs < 0)
+				end_ofs = 0;
+		}
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	float fh = int(font->get_height() * 1.5);
+
+	float len = stream->get_length();
+
+	Ref<AudioStreamPreview> preview = AudioStreamPreviewGenerator::get_singleton()->generate_preview(stream);
+
+	float preview_len = preview->get_length();
+
+	if (len == 0) {
+		len = preview_len;
+	}
+
+	int pixel_total_len = len * p_pixels_sec;
+
+	len -= end_ofs;
+	len -= start_ofs;
+
+	if (len <= 0.001) {
+		len = 0.001;
+	}
+
+	int pixel_len = len * p_pixels_sec;
+
+	int pixel_begin = p_x;
+	int pixel_end = p_x + pixel_len;
+
+	if (pixel_end < p_clip_left)
+		return;
+
+	if (pixel_begin > p_clip_right)
+		return;
+
+	int from_x = MAX(pixel_begin, p_clip_left);
+	int to_x = MIN(pixel_end, p_clip_right);
+
+	if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+		float limit = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		int limit_x = pixel_begin + limit * p_pixels_sec;
+		to_x = MIN(limit_x, to_x);
+	}
+
+	if (to_x <= from_x) {
+		to_x = from_x + 1;
+	}
+
+	int h = get_size().height;
+	Rect2 rect = Rect2(from_x, (h - fh) / 2, to_x - from_x, fh);
+	draw_rect(rect, Color(0.25, 0.25, 0.25));
+
+	Vector<Vector2> lines;
+	lines.resize((to_x - from_x + 1) * 2);
+	preview_len = preview->get_length();
+
+	for (int i = from_x; i < to_x; i++) {
+
+		float ofs = (i - pixel_begin) * preview_len / pixel_total_len;
+		float ofs_n = ((i + 1) - pixel_begin) * preview_len / pixel_total_len;
+		ofs += start_ofs;
+		ofs_n += start_ofs;
+
+		float max = preview->get_max(ofs, ofs_n) * 0.5 + 0.5;
+		float min = preview->get_min(ofs, ofs_n) * 0.5 + 0.5;
+
+		int idx = i - from_x;
+		lines[idx * 2 + 0] = Vector2(i, rect.position.y + min * rect.size.y);
+		lines[idx * 2 + 1] = Vector2(i, rect.position.y + max * rect.size.y);
+	}
+
+	Vector<Color> color;
+	color.push_back(Color(0.75, 0.75, 0.75));
+
+	VS::get_singleton()->canvas_item_add_multiline(get_canvas_item(), lines, color);
+
+	Color cut_color = get_color("accent_color", "Editor");
+	cut_color.a = 0.7;
+	if (start_ofs > 0 && pixel_begin > p_clip_left) {
+		draw_rect(Rect2(pixel_begin, rect.position.y, 1, rect.size.y), cut_color);
+	}
+	if (end_ofs > 0 && pixel_end < p_clip_right) {
+		draw_rect(Rect2(pixel_end, rect.position.y, 1, rect.size.y), cut_color);
+	}
+
+	if (p_selected) {
+		Color accent = get_color("accent_color", "Editor");
+		draw_rect(rect, accent, false);
+	}
+}
+
+void AnimationTrackEditTypeAudio::_bind_methods() {
+	ClassDB::bind_method("_preview_changed", &AnimationTrackEditTypeAudio::_preview_changed);
+}
+
+AnimationTrackEditTypeAudio::AnimationTrackEditTypeAudio() {
+	AudioStreamPreviewGenerator::get_singleton()->connect("preview_updated", this, "_preview_changed");
+	len_resizing = false;
+}
+
+bool AnimationTrackEditTypeAudio::can_drop_data(const Point2 &p_point, const Variant &p_data) const {
+
+	if (p_point.x > get_timeline()->get_name_limit() && p_point.x < get_size().width - get_timeline()->get_buttons_width()) {
+
+		Dictionary drag_data = p_data;
+		if (drag_data.has("type") && String(drag_data["type"]) == "resource") {
+			Ref<AudioStream> res = drag_data["resource"];
+			if (res.is_valid()) {
+				return true;
+			}
+		}
+
+		if (drag_data.has("type") && String(drag_data["type"]) == "files") {
+
+			Vector<String> files = drag_data["files"];
+
+			if (files.size() == 1) {
+				String file = files[0];
+				Ref<AudioStream> res = ResourceLoader::load(file);
+				if (res.is_valid()) {
+					return true;
+				}
+			}
+		}
+	}
+
+	return AnimationTrackEdit::can_drop_data(p_point, p_data);
+}
+void AnimationTrackEditTypeAudio::drop_data(const Point2 &p_point, const Variant &p_data) {
+
+	if (p_point.x > get_timeline()->get_name_limit() && p_point.x < get_size().width - get_timeline()->get_buttons_width()) {
+
+		Ref<AudioStream> stream;
+		Dictionary drag_data = p_data;
+		if (drag_data.has("type") && String(drag_data["type"]) == "resource") {
+			stream = drag_data["resource"];
+		} else if (drag_data.has("type") && String(drag_data["type"]) == "files") {
+
+			Vector<String> files = drag_data["files"];
+
+			if (files.size() == 1) {
+				String file = files[0];
+				stream = ResourceLoader::load(file);
+			}
+		}
+
+		if (stream.is_valid()) {
+
+			int x = p_point.x - get_timeline()->get_name_limit();
+			float ofs = x / get_timeline()->get_zoom_scale();
+			ofs += get_timeline()->get_value();
+
+			ofs = get_editor()->snap_time(ofs);
+
+			while (get_animation()->track_find_key(get_track(), ofs, true) != -1) { //make sure insertion point is valid
+				ofs += 0.001;
+			}
+
+			print_line("inserting");
+
+			*get_block_animation_update_ptr() = true;
+			get_undo_redo()->create_action("Add Audio Track Clip");
+			get_undo_redo()->add_do_method(get_animation().ptr(), "audio_track_insert_key", get_track(), ofs, stream);
+			get_undo_redo()->add_undo_method(get_animation().ptr(), "track_remove_key_at_position", get_track(), ofs);
+			get_undo_redo()->commit_action();
+			*get_block_animation_update_ptr() = false;
+
+			update();
+			return;
+		}
+	}
+
+	return AnimationTrackEdit::drop_data(p_point, p_data);
+}
+
+void AnimationTrackEditTypeAudio::_gui_input(const Ref<InputEvent> &p_event) {
+
+	Ref<InputEventMouseMotion> mm = p_event;
+	if (!len_resizing && mm.is_valid()) {
+		bool use_hsize_cursor = false;
+		for (int i = 0; i < get_animation()->track_get_key_count(get_track()); i++) {
+
+			Ref<AudioStream> stream = get_animation()->audio_track_get_key_stream(get_track(), i);
+
+			if (!stream.is_valid()) {
+				continue;
+			}
+
+			float start_ofs = get_animation()->audio_track_get_key_start_offset(get_track(), i);
+			float end_ofs = get_animation()->audio_track_get_key_end_offset(get_track(), i);
+			float len = stream->get_length();
+
+			if (len == 0) {
+				Ref<AudioStreamPreview> preview = AudioStreamPreviewGenerator::get_singleton()->generate_preview(stream);
+				float preview_len = preview->get_length();
+				len = preview_len;
+			}
+
+			len -= end_ofs;
+			len -= start_ofs;
+			if (len <= 0.001) {
+				len = 0.001;
+			}
+
+			if (get_animation()->track_get_key_count(get_track()) > i + 1) {
+				len = MIN(len, get_animation()->track_get_key_time(get_track(), i + 1) - get_animation()->track_get_key_time(get_track(), i));
+			}
+
+			float ofs = get_animation()->track_get_key_time(get_track(), i);
+
+			ofs -= get_timeline()->get_value();
+			ofs *= get_timeline()->get_zoom_scale();
+			ofs += get_timeline()->get_name_limit();
+
+			int end = ofs + len * get_timeline()->get_zoom_scale();
+
+			if (end >= get_timeline()->get_name_limit() && end <= get_size().width - get_timeline()->get_buttons_width() && ABS(mm->get_position().x - end) < 5 * EDSCALE) {
+				use_hsize_cursor = true;
+				len_resizing_index = i;
+			}
+		}
+
+		if (use_hsize_cursor) {
+			set_default_cursor_shape(CURSOR_HSIZE);
+		} else {
+			set_default_cursor_shape(CURSOR_ARROW);
+		}
+	}
+
+	if (len_resizing && mm.is_valid()) {
+		len_resizing_rel += mm->get_relative().x;
+		len_resizing_start = mm->get_shift();
+		update();
+		accept_event();
+		return;
+	}
+
+	Ref<InputEventMouseButton> mb = p_event;
+	if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && get_default_cursor_shape() == CURSOR_HSIZE) {
+
+		len_resizing = true;
+		len_resizing_start = mb->get_shift();
+		len_resizing_from_px = mb->get_position().x;
+		len_resizing_rel = 0;
+		update();
+		accept_event();
+		return;
+	}
+
+	if (len_resizing && mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
+
+		float ofs_local = -len_resizing_rel / get_timeline()->get_zoom_scale();
+		if (len_resizing_start) {
+			float prev_ofs = get_animation()->audio_track_get_key_start_offset(get_track(), len_resizing_index);
+			*get_block_animation_update_ptr() = true;
+			get_undo_redo()->create_action("Change Audio Track Clip Start Offset");
+			get_undo_redo()->add_do_method(get_animation().ptr(), "audio_track_set_key_start_offset", get_track(), len_resizing_index, prev_ofs + ofs_local);
+			get_undo_redo()->add_undo_method(get_animation().ptr(), "audio_track_set_key_start_offset", get_track(), len_resizing_index, prev_ofs);
+			get_undo_redo()->commit_action();
+			*get_block_animation_update_ptr() = false;
+
+		} else {
+			float prev_ofs = get_animation()->audio_track_get_key_end_offset(get_track(), len_resizing_index);
+			*get_block_animation_update_ptr() = true;
+			get_undo_redo()->create_action("Change Audio Track Clip End Offset");
+			get_undo_redo()->add_do_method(get_animation().ptr(), "audio_track_set_key_end_offset", get_track(), len_resizing_index, prev_ofs + ofs_local);
+			get_undo_redo()->add_undo_method(get_animation().ptr(), "audio_track_set_key_end_offset", get_track(), len_resizing_index, prev_ofs);
+			get_undo_redo()->commit_action();
+			*get_block_animation_update_ptr() = false;
+		}
+
+		len_resizing = false;
+		len_resizing_index = -1;
+		update();
+		accept_event();
+		return;
+	}
+
+	AnimationTrackEdit::_gui_input(p_event);
+}
+
+////////////////////
+/// SUB ANIMATION ///
+
+int AnimationTrackEditTypeAnimation::get_key_height() const {
+
+	if (!ObjectDB::get_instance(id)) {
+		return AnimationTrackEdit::get_key_height();
+	}
+
+	Ref<Font> font = get_font("font", "Label");
+	return int(font->get_height() * 1.5);
+}
+Rect2 AnimationTrackEditTypeAnimation::get_key_rect(int p_index, float p_pixels_sec) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(object);
+
+	if (!ap) {
+		return AnimationTrackEdit::get_key_rect(p_index, p_pixels_sec);
+	}
+
+	String anim = get_animation()->animation_track_get_key_animation(get_track(), p_index);
+	print_line("anim " + anim + " has " + itos(ap->has_animation(anim)));
+
+	if (anim != "[stop]" && ap->has_animation(anim)) {
+
+		float len = ap->get_animation(anim)->get_length();
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		}
+
+		return Rect2(0, 0, len * p_pixels_sec, get_size().height);
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		return Rect2(0, 0, fh, get_size().height);
+	}
+}
+
+bool AnimationTrackEditTypeAnimation::is_key_selectable_by_distance() const {
+
+	return false;
+}
+void AnimationTrackEditTypeAnimation::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
+
+	Object *object = ObjectDB::get_instance(id);
+
+	if (!object) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(object);
+
+	if (!ap) {
+		AnimationTrackEdit::draw_key(p_index, p_pixels_sec, p_x, p_selected, p_clip_left, p_clip_right);
+		return;
+	}
+
+	String anim = get_animation()->animation_track_get_key_animation(get_track(), p_index);
+
+	if (anim != "[stop]" && ap->has_animation(anim)) {
+
+		float len = ap->get_animation(anim)->get_length();
+
+		if (get_animation()->track_get_key_count(get_track()) > p_index + 1) {
+			len = MIN(len, get_animation()->track_get_key_time(get_track(), p_index + 1) - get_animation()->track_get_key_time(get_track(), p_index));
+		}
+
+		int pixel_len = len * p_pixels_sec;
+
+		int pixel_begin = p_x;
+		int pixel_end = p_x + pixel_len;
+
+		if (pixel_end < p_clip_left)
+			return;
+
+		if (pixel_begin > p_clip_right)
+			return;
+
+		int from_x = MAX(pixel_begin, p_clip_left);
+		int to_x = MIN(pixel_end, p_clip_right);
+
+		if (to_x <= from_x)
+			return;
+
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 1.5;
+
+		Rect2 rect(from_x, int(get_size().height - fh) / 2, to_x - from_x, fh);
+
+		Color color = get_color("font_color", "Label");
+		Color bg = color;
+		bg.r = 1 - color.r;
+		bg.g = 1 - color.g;
+		bg.b = 1 - color.b;
+		draw_rect(rect, bg);
+
+		Vector<Vector2> lines;
+		Vector<Color> colorv;
+		{
+			Ref<Animation> animation = ap->get_animation(anim);
+
+			for (int i = 0; i < animation->get_track_count(); i++) {
+
+				float h = (rect.size.height - 2) / animation->get_track_count();
+
+				int y = 2 + h * i + h / 2;
+
+				for (int j = 0; j < animation->track_get_key_count(i); j++) {
+
+					float ofs = animation->track_get_key_time(i, j);
+					int x = p_x + ofs * p_pixels_sec + 2;
+
+					if (x < from_x || x >= (to_x - 4))
+						continue;
+
+					lines.push_back(Point2(x, y));
+					lines.push_back(Point2(x + 1, y));
+				}
+			}
+
+			colorv.push_back(color);
+		}
+
+		if (lines.size() > 2) {
+			VS::get_singleton()->canvas_item_add_multiline(get_canvas_item(), lines, colorv);
+		}
+
+		int limit = to_x - from_x - 4;
+		if (limit > 0) {
+			draw_string(font, Point2(from_x + 2, int(get_size().height - font->get_height()) / 2 + font->get_ascent()), anim, color);
+		}
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	} else {
+		Ref<Font> font = get_font("font", "Label");
+		int fh = font->get_height() * 0.8;
+		Rect2 rect(Vector2(p_x, int(get_size().height - fh) / 2), Size2(fh, fh));
+
+		Color color = get_color("font_color", "Label");
+		draw_rect(rect, color);
+
+		if (p_selected) {
+			Color accent = get_color("accent_color", "Editor");
+			draw_rect(rect, accent, false);
+		}
+	}
+}
+
+void AnimationTrackEditTypeAnimation::set_node(Object *p_object) {
+
+	id = p_object->get_instance_id();
+}
+
+AnimationTrackEditTypeAnimation::AnimationTrackEditTypeAnimation() {
+}
+
+/////////
+AnimationTrackEdit *AnimationTrackEditDefaultPlugin::create_value_track_edit(Object *p_object, Variant::Type p_type, const String &p_property, PropertyHint p_hint, const String &p_hint_string, int p_usage) {
+
+	if (p_property == "playing" && (p_object->is_class("AudioStreamPlayer") || p_object->is_class("AudioStreamPlayer2D") || p_object->is_class("AudioStreamPlayer3D"))) {
+
+		AnimationTrackEditAudio *audio = memnew(AnimationTrackEditAudio);
+		audio->set_node(p_object);
+		return audio;
+	}
+
+	if (p_property == "frame" && (p_object->is_class("Sprite") || p_object->is_class("Sprite3D") || p_object->is_class("AnimatedSprite") || p_object->is_class("AnimatedSprite3D"))) {
+
+		AnimationTrackEditSpriteFrame *sprite = memnew(AnimationTrackEditSpriteFrame);
+		sprite->set_node(p_object);
+		return sprite;
+	}
+
+	if (p_property == "current_animation" && (p_object->is_class("AnimationPlayer"))) {
+
+		AnimationTrackEditSubAnim *player = memnew(AnimationTrackEditSubAnim);
+		player->set_node(p_object);
+		return player;
+	}
+
+	if (p_property == "volume_db") {
+
+		AnimationTrackEditVolumeDB *vu = memnew(AnimationTrackEditVolumeDB);
+		return vu;
+	}
+
+	if (p_type == Variant::BOOL) {
+		return memnew(AnimationTrackEditBool);
+	}
+	if (p_type == Variant::COLOR) {
+		return memnew(AnimationTrackEditColor);
+	}
+
+	return NULL;
+}
+
+AnimationTrackEdit *AnimationTrackEditDefaultPlugin::create_audio_track_edit() {
+
+	return memnew(AnimationTrackEditTypeAudio);
+}
+
+AnimationTrackEdit *AnimationTrackEditDefaultPlugin::create_animation_track_edit(Object *p_object) {
+
+	AnimationTrackEditTypeAnimation *an = memnew(AnimationTrackEditTypeAnimation);
+	an->set_node(p_object);
+	return an;
+}