1 files changed, 210 insertions, 17 deletions

diff --git a/scene/gui/rich_text_label.h b/scene/gui/rich_text_label.h
index 21d099c37a..481f8d9746 100644
--- a/scene/gui/rich_text_label.h
+++ b/scene/gui/rich_text_label.h
@@ -31,6 +31,7 @@
 #ifndef RICH_TEXT_LABEL_H
 #define RICH_TEXT_LABEL_H
 
+#include "rich_text_effect.h"
 #include "scene/gui/scroll_bar.h"
 
 class RichTextLabel : public Control {
@@ -67,14 +68,20 @@ public:
 		ITEM_INDENT,
 		ITEM_LIST,
 		ITEM_TABLE,
-		ITEM_META
+		ITEM_FADE,
+		ITEM_SHAKE,
+		ITEM_WAVE,
+		ITEM_TORNADO,
+		ITEM_RAINBOW,
+		ITEM_META,
+		ITEM_CUSTOMFX
 	};
 
 protected:
 	static void _bind_methods();
 
 private:
-	struct Item;
+	class Item;
 
 	struct Line {
 
@@ -96,8 +103,10 @@ private:
 		}
 	};
 
-	struct Item {
+	class Item : public Object {
+		GDCLASS(Item, Object);
 
+	public:
 		int index;
 		Item *parent;
 		ItemType type;
@@ -120,8 +129,10 @@ private:
 		virtual ~Item() { _clear_children(); }
 	};
 
-	struct ItemFrame : public Item {
+	class ItemFrame : public Item {
+		GDCLASS(ItemFrame, Item);
 
+	public:
 		int parent_line;
 		bool cell;
 		Vector<Line> lines;
@@ -136,71 +147,95 @@ private:
 		}
 	};
 
-	struct ItemText : public Item {
+	class ItemText : public Item {
+		GDCLASS(ItemText, Item);
 
+	public:
 		String text;
 		ItemText() { type = ITEM_TEXT; }
 	};
 
-	struct ItemImage : public Item {
+	class ItemImage : public Item {
+		GDCLASS(ItemImage, Item);
 
+	public:
 		Ref<Texture> image;
 		ItemImage() { type = ITEM_IMAGE; }
 	};
 
-	struct ItemFont : public Item {
+	class ItemFont : public Item {
+		GDCLASS(ItemFont, Item);
 
+	public:
 		Ref<Font> font;
 		ItemFont() { type = ITEM_FONT; }
 	};
 
-	struct ItemColor : public Item {
+	class ItemColor : public Item {
+		GDCLASS(ItemColor, Item);
 
+	public:
 		Color color;
 		ItemColor() { type = ITEM_COLOR; }
 	};
 
-	struct ItemUnderline : public Item {
+	class ItemUnderline : public Item {
+		GDCLASS(ItemUnderline, Item);
 
+	public:
 		ItemUnderline() { type = ITEM_UNDERLINE; }
 	};
 
-	struct ItemStrikethrough : public Item {
+	class ItemStrikethrough : public Item {
+		GDCLASS(ItemStrikethrough, Item);
 
+	public:
 		ItemStrikethrough() { type = ITEM_STRIKETHROUGH; }
 	};
 
-	struct ItemMeta : public Item {
+	class ItemMeta : public Item {
+		GDCLASS(ItemMeta, Item);
 
+	public:
 		Variant meta;
 		ItemMeta() { type = ITEM_META; }
 	};
 
-	struct ItemAlign : public Item {
+	class ItemAlign : public Item {
+		GDCLASS(ItemAlign, Item);
 
+	public:
 		Align align;
 		ItemAlign() { type = ITEM_ALIGN; }
 	};
 
-	struct ItemIndent : public Item {
+	class ItemIndent : public Item {
+		GDCLASS(ItemIndent, Item);
 
+	public:
 		int level;
 		ItemIndent() { type = ITEM_INDENT; }
 	};
 
-	struct ItemList : public Item {
+	class ItemList : public Item {
+		GDCLASS(ItemList, Item);
 
+	public:
 		ListType list_type;
 		ItemList() { type = ITEM_LIST; }
 	};
 
-	struct ItemNewline : public Item {
+	class ItemNewline : public Item {
+		GDCLASS(ItemNewline, Item);
 
+	public:
 		ItemNewline() { type = ITEM_NEWLINE; }
 	};
 
-	struct ItemTable : public Item {
+	class ItemTable : public Item {
+		GDCLASS(ItemTable, Item);
 
+	public:
 		struct Column {
 			bool expand;
 			int expand_ratio;
@@ -214,6 +249,122 @@ private:
 		ItemTable() { type = ITEM_TABLE; }
 	};
 
+	class ItemFade : public Item {
+		GDCLASS(ItemFade, Item);
+
+	public:
+		int starting_index;
+		int length;
+
+		ItemFade() { type = ITEM_FADE; }
+	};
+
+	class ItemFX : public Item {
+		GDCLASS(ItemFX, Item);
+
+	public:
+		float elapsed_time;
+
+		ItemFX() {
+			elapsed_time = 0.0f;
+		}
+	};
+
+	class ItemShake : public ItemFX {
+		GDCLASS(ItemShake, ItemFX);
+
+	public:
+		int strength;
+		float rate;
+		uint64_t _current_rng;
+		uint64_t _previous_rng;
+
+		ItemShake() {
+			strength = 0;
+			rate = 0.0f;
+			_current_rng = 0;
+			type = ITEM_SHAKE;
+		}
+
+		void reroll_random() {
+			_previous_rng = _current_rng;
+			_current_rng = Math::rand();
+		}
+
+		uint64_t offset_random(int index) {
+			return (_current_rng >> (index % 64)) |
+				   (_current_rng << (64 - (index % 64)));
+		}
+
+		uint64_t offset_previous_random(int index) {
+			return (_previous_rng >> (index % 64)) |
+				   (_previous_rng << (64 - (index % 64)));
+		}
+	};
+
+	class ItemWave : public ItemFX {
+		GDCLASS(ItemWave, ItemFX);
+
+	public:
+		float frequency;
+		float amplitude;
+
+		ItemWave() {
+			frequency = 1.0f;
+			amplitude = 1.0f;
+			type = ITEM_WAVE;
+		}
+	};
+
+	class ItemTornado : public ItemFX {
+		GDCLASS(ItemTornado, ItemFX);
+
+	public:
+		float radius;
+		float frequency;
+
+		ItemTornado() {
+			radius = 1.0f;
+			frequency = 1.0f;
+			type = ITEM_TORNADO;
+		}
+	};
+
+	class ItemRainbow : public ItemFX {
+		GDCLASS(ItemRainbow, ItemFX);
+
+	public:
+		float saturation;
+		float value;
+		float frequency;
+
+		ItemRainbow() {
+			saturation = 0.8f;
+			value = 0.8f;
+			frequency = 1.0f;
+			type = ITEM_RAINBOW;
+		}
+	};
+
+	class ItemCustomFX : public ItemFX {
+		GDCLASS(ItemCustomFX, ItemFX);
+
+	public:
+		String identifier;
+		Dictionary environment;
+
+		ItemCustomFX() {
+			identifier = "";
+			environment = Dictionary();
+			type = ITEM_CUSTOMFX;
+		}
+
+		virtual ~ItemCustomFX() {
+			_clear_children();
+			environment.clear();
+		}
+	};
+
 	ItemFrame *main;
 	Item *current;
 	ItemFrame *current_frame;
@@ -239,6 +390,8 @@ private:
 	ItemMeta *meta_hovering;
 	Variant current_meta;
 
+	Vector<Ref<RichTextEffect> > custom_effects;
+
 	void _invalidate_current_line(ItemFrame *p_frame);
 	void _validate_line_caches(ItemFrame *p_frame);
 
@@ -246,7 +399,6 @@ private:
 	void _remove_item(Item *p_item, const int p_line, const int p_subitem_line);
 
 	struct ProcessState {
-
 		int line_width;
 	};
 
@@ -287,8 +439,36 @@ private:
 	bool _find_strikethrough(Item *p_item);
 	bool _find_meta(Item *p_item, Variant *r_meta, ItemMeta **r_item = NULL);
 	bool _find_layout_subitem(Item *from, Item *to);
+	bool _find_by_type(Item *p_item, ItemType p_type);
+	template <typename T>
+	T *_fetch_by_type(Item *p_item, ItemType p_type) {
+		Item *item = p_item;
+		T *result = NULL;
+		while (item) {
+			if (item->type == p_type) {
+				result = Object::cast_to<T>(item);
+				if (result)
+					return result;
+			}
+			item = item->parent;
+		}
+
+		return result;
+	};
+	template <typename T>
+	void _fetch_item_stack(Item *p_item, Vector<T *> &r_stack) {
+		Item *item = p_item;
+		while (item) {
+			T *found = Object::cast_to<T>(item);
+			if (found) {
+				r_stack.push_back(found);
+			}
+			item = item->parent;
+		}
+	}
 
 	void _update_scroll();
+	void _update_fx(ItemFrame *p_frame, float p_delta_time);
 	void _scroll_changed(double);
 
 	void _gui_input(Ref<InputEvent> p_event);
@@ -296,6 +476,8 @@ private:
 	Item *_get_prev_item(Item *p_item, bool p_free = false);
 
 	Rect2 _get_text_rect();
+	Ref<RichTextEffect> _get_custom_effect_by_code(String p_bbcode_identifier);
+	virtual Dictionary parse_expressions_for_values(Vector<String> p_expressions);
 
 	bool use_bbcode;
 	String bbcode;
@@ -322,6 +504,12 @@ public:
 	void push_list(ListType p_list);
 	void push_meta(const Variant &p_meta);
 	void push_table(int p_columns);
+	void push_fade(int p_start_index, int p_length);
+	void push_shake(int p_strength, float p_rate);
+	void push_wave(float p_frequency, float p_amplitude);
+	void push_tornado(float p_frequency, float p_radius);
+	void push_rainbow(float p_saturation, float p_value, float p_frequency);
+	void push_customfx(String p_identifier, Dictionary p_environment);
 	void set_table_column_expand(int p_column, bool p_expand, int p_ratio = 1);
 	int get_current_table_column() const;
 	void push_cell();
@@ -380,6 +568,11 @@ public:
 	void set_percent_visible(float p_percent);
 	float get_percent_visible() const;
 
+	void set_effects(const Vector<Variant> &effects);
+	Vector<Variant> get_effects();
+
+	void install_effect(const Variant effect);
+
 	void set_fixed_size_to_width(int p_width);
 	virtual Size2 get_minimum_size() const;