3 files changed, 274 insertions, 1 deletions

diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index 2064bf9b04..8dd378c319 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -603,6 +603,7 @@ void register_scene_types() {
 	ClassDB::register_class<CurveTexture>();
 	ClassDB::register_class<GradientTexture>();
 	ClassDB::register_class<ProxyTexture>();
+	ClassDB::register_class<AnimatedTexture>();
 	ClassDB::register_class<CubeMap>();
 	ClassDB::register_class<Animation>();
 	ClassDB::register_virtual_class<Font>();
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index 54f5aea160..2baad555c0 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -1669,3 +1669,208 @@ ProxyTexture::~ProxyTexture() {
 
 	VS::get_singleton()->free(proxy);
 }
+//////////////////////////////////////////////
+
+void AnimatedTexture::_update_proxy() {
+
+	_THREAD_SAFE_METHOD_
+
+	float delta;
+	if (prev_ticks == 0) {
+		delta = 0;
+		prev_ticks = OS::get_singleton()->get_ticks_usec();
+	} else {
+		uint64_t ticks = OS::get_singleton()->get_ticks_usec();
+		delta = float(double(ticks - prev_ticks) / 1000000.0);
+		prev_ticks = ticks;
+	}
+
+	time += delta;
+
+	float limit;
+
+	if (fps == 0) {
+		limit = 0;
+	} else {
+		limit = 1.0 / fps;
+	}
+
+	int iter_max = frame_count;
+	while (iter_max) {
+		float frame_limit = limit + frames[current_frame].delay_sec;
+
+		if (time > frame_limit) {
+			current_frame++;
+			if (current_frame >= frame_count) {
+				current_frame = 0;
+			}
+			time -= frame_limit;
+		} else {
+			break;
+		}
+		iter_max--;
+	}
+
+	if (frames[current_frame].texture.is_valid()) {
+		VisualServer::get_singleton()->texture_set_proxy(proxy, frames[current_frame].texture->get_rid());
+	}
+}
+
+void AnimatedTexture::set_frames(int p_frames) {
+	ERR_FAIL_COND(p_frames < 1 || p_frames > MAX_FRAMES);
+
+	_THREAD_SAFE_METHOD_
+
+	frame_count = p_frames;
+}
+int AnimatedTexture::get_frames() const {
+	return frame_count;
+}
+
+void AnimatedTexture::set_frame_texture(int p_frame, const Ref<Texture> &p_texture) {
+	ERR_FAIL_INDEX(p_frame, MAX_FRAMES);
+
+	_THREAD_SAFE_METHOD_
+
+	frames[p_frame].texture = p_texture;
+}
+Ref<Texture> AnimatedTexture::get_frame_texture(int p_frame) const {
+	ERR_FAIL_INDEX_V(p_frame, MAX_FRAMES, Ref<Texture>());
+
+	_THREAD_SAFE_METHOD_
+
+	return frames[p_frame].texture;
+}
+
+void AnimatedTexture::set_frame_delay(int p_frame, float p_delay_sec) {
+	ERR_FAIL_INDEX(p_frame, MAX_FRAMES);
+
+	_THREAD_SAFE_METHOD_
+
+	frames[p_frame].delay_sec = p_delay_sec;
+}
+float AnimatedTexture::get_frame_delay(int p_frame) const {
+	ERR_FAIL_INDEX_V(p_frame, MAX_FRAMES, 0);
+
+	_THREAD_SAFE_METHOD_
+
+	return frames[p_frame].delay_sec;
+}
+
+void AnimatedTexture::set_fps(float p_fps) {
+	ERR_FAIL_COND(p_fps < 0 || p_fps >= 1000);
+
+	fps = p_fps;
+}
+float AnimatedTexture::get_fps() const {
+	return fps;
+}
+
+int AnimatedTexture::get_width() const {
+
+	_THREAD_SAFE_METHOD_
+
+	if (!frames[current_frame].texture.is_valid()) {
+		return 1;
+	}
+
+	return frames[current_frame].texture->get_width();
+}
+int AnimatedTexture::get_height() const {
+
+	_THREAD_SAFE_METHOD_
+
+	if (!frames[current_frame].texture.is_valid()) {
+		return 1;
+	}
+
+	return frames[current_frame].texture->get_height();
+}
+RID AnimatedTexture::get_rid() const {
+	return proxy;
+}
+
+bool AnimatedTexture::has_alpha() const {
+
+	_THREAD_SAFE_METHOD_
+
+	if (!frames[current_frame].texture.is_valid()) {
+		return false;
+	}
+
+	return frames[current_frame].texture->has_alpha();
+}
+
+Ref<Image> AnimatedTexture::get_data() const {
+
+	_THREAD_SAFE_METHOD_
+
+	if (!frames[current_frame].texture.is_valid()) {
+		return Ref<Image>();
+	}
+
+	return frames[current_frame].texture->get_data();
+}
+
+void AnimatedTexture::set_flags(uint32_t p_flags) {
+}
+uint32_t AnimatedTexture::get_flags() const {
+
+	_THREAD_SAFE_METHOD_
+
+	if (!frames[current_frame].texture.is_valid()) {
+		return 0;
+	}
+
+	return frames[current_frame].texture->get_flags();
+}
+
+void AnimatedTexture::_validate_property(PropertyInfo &property) const {
+
+	String prop = property.name;
+	if (prop.begins_with("frame_")) {
+		int frame = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
+		if (frame >= frame_count) {
+			property.usage = 0;
+		}
+	}
+}
+
+void AnimatedTexture::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_frames", "frames"), &AnimatedTexture::set_frames);
+	ClassDB::bind_method(D_METHOD("get_frames"), &AnimatedTexture::get_frames);
+
+	ClassDB::bind_method(D_METHOD("set_fps", "fps"), &AnimatedTexture::set_fps);
+	ClassDB::bind_method(D_METHOD("get_fps"), &AnimatedTexture::get_fps);
+
+	ClassDB::bind_method(D_METHOD("set_frame_texture", "frame", "texture"), &AnimatedTexture::set_frame_texture);
+	ClassDB::bind_method(D_METHOD("get_frame_texture", "frame"), &AnimatedTexture::get_frame_texture);
+
+	ClassDB::bind_method(D_METHOD("set_frame_delay", "frame", "delay"), &AnimatedTexture::set_frame_delay);
+	ClassDB::bind_method(D_METHOD("get_frame_delay", "frame"), &AnimatedTexture::get_frame_delay);
+
+	ClassDB::bind_method(D_METHOD("_update_proxy"), &AnimatedTexture::_update_proxy);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "frames", PROPERTY_HINT_RANGE, "1," + itos(MAX_FRAMES), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_frames", "get_frames");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "fps", PROPERTY_HINT_RANGE, "0,1024,0.1"), "set_fps", "get_fps");
+
+	for (int i = 0; i < MAX_FRAMES; i++) {
+		ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "frame_" + itos(i) + "/texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_frame_texture", "get_frame_texture", i);
+		ADD_PROPERTYI(PropertyInfo(Variant::REAL, "frame_" + itos(i) + "/delay_sec", PROPERTY_HINT_RANGE, "0.0,16.0,0.01"), "set_frame_delay", "get_frame_delay", i);
+	}
+}
+
+AnimatedTexture::AnimatedTexture() {
+	proxy = VS::get_singleton()->texture_create();
+	VisualServer::get_singleton()->texture_set_force_redraw_if_visible(proxy, true);
+	time = 0;
+	frame_count = 1;
+	fps = 4;
+	prev_ticks = 0;
+	current_frame = 0;
+	VisualServer::get_singleton()->connect("frame_pre_draw", this, "_update_proxy");
+}
+
+AnimatedTexture::~AnimatedTexture() {
+	VS::get_singleton()->free(proxy);
+}
diff --git a/scene/resources/texture.h b/scene/resources/texture.h
index d81fd3b19b..c994bdad5f 100644
--- a/scene/resources/texture.h
+++ b/scene/resources/texture.h
@@ -34,10 +34,11 @@
 #include "curve.h"
 #include "io/resource_loader.h"
 #include "math_2d.h"
+#include "os/mutex.h"
+#include "os/thread_safe.h"
 #include "resource.h"
 #include "scene/resources/color_ramp.h"
 #include "servers/visual_server.h"
-
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
@@ -521,4 +522,70 @@ public:
 	~ProxyTexture();
 };
 
+class AnimatedTexture : public Texture {
+	GDCLASS(AnimatedTexture, Texture)
+
+	_THREAD_SAFE_CLASS_
+
+private:
+	enum {
+		MAX_FRAMES = 256
+	};
+
+	RID proxy;
+
+	struct Frame {
+
+		Ref<Texture> texture;
+		float delay_sec;
+
+		Frame() {
+			delay_sec = 0;
+		}
+	};
+
+	Frame frames[MAX_FRAMES];
+	int frame_count;
+	int current_frame;
+
+	float fps;
+
+	float time;
+
+	uint64_t prev_ticks;
+
+	void _update_proxy();
+
+protected:
+	static void _bind_methods();
+	void _validate_property(PropertyInfo &property) const;
+
+public:
+	void set_frames(int p_frames);
+	int get_frames() const;
+
+	void set_frame_texture(int p_frame, const Ref<Texture> &p_texture);
+	Ref<Texture> get_frame_texture(int p_frame) const;
+
+	void set_frame_delay(int p_frame, float p_delay_sec);
+	float get_frame_delay(int p_frame) const;
+
+	void set_fps(float p_fps);
+	float get_fps() const;
+
+	virtual int get_width() const;
+	virtual int get_height() const;
+	virtual RID get_rid() const;
+
+	virtual bool has_alpha() const;
+
+	virtual void set_flags(uint32_t p_flags);
+	virtual uint32_t get_flags() const;
+
+	virtual Ref<Image> get_data() const;
+
+	AnimatedTexture();
+	~AnimatedTexture();
+};
+
 #endif