Implement a BitField hint

Allows to specify the binder that an enum must be treated as a bitfield.

10 files changed, 132 insertions, 26 deletions

diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index 24b27d2692..26ecd41353 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -147,7 +147,7 @@ void ResourceLoader::_bind_methods() {
 
 ////// ResourceSaver //////
 
-Error ResourceSaver::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
+Error ResourceSaver::save(const String &p_path, const Ref<Resource> &p_resource, BitField<SaverFlags> p_flags) {
 	ERR_FAIL_COND_V_MSG(p_resource.is_null(), ERR_INVALID_PARAMETER, "Can't save empty resource to path '" + String(p_path) + "'.");
 	return ::ResourceSaver::save(p_path, p_resource, p_flags);
 }
@@ -179,14 +179,14 @@ void ResourceSaver::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("add_resource_format_saver", "format_saver", "at_front"), &ResourceSaver::add_resource_format_saver, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("remove_resource_format_saver", "format_saver"), &ResourceSaver::remove_resource_format_saver);
 
-	BIND_ENUM_CONSTANT(FLAG_NONE);
-	BIND_ENUM_CONSTANT(FLAG_RELATIVE_PATHS);
-	BIND_ENUM_CONSTANT(FLAG_BUNDLE_RESOURCES);
-	BIND_ENUM_CONSTANT(FLAG_CHANGE_PATH);
-	BIND_ENUM_CONSTANT(FLAG_OMIT_EDITOR_PROPERTIES);
-	BIND_ENUM_CONSTANT(FLAG_SAVE_BIG_ENDIAN);
-	BIND_ENUM_CONSTANT(FLAG_COMPRESS);
-	BIND_ENUM_CONSTANT(FLAG_REPLACE_SUBRESOURCE_PATHS);
+	BIND_BITFIELD_FLAG(FLAG_NONE);
+	BIND_BITFIELD_FLAG(FLAG_RELATIVE_PATHS);
+	BIND_BITFIELD_FLAG(FLAG_BUNDLE_RESOURCES);
+	BIND_BITFIELD_FLAG(FLAG_CHANGE_PATH);
+	BIND_BITFIELD_FLAG(FLAG_OMIT_EDITOR_PROPERTIES);
+	BIND_BITFIELD_FLAG(FLAG_SAVE_BIG_ENDIAN);
+	BIND_BITFIELD_FLAG(FLAG_COMPRESS);
+	BIND_BITFIELD_FLAG(FLAG_REPLACE_SUBRESOURCE_PATHS);
 }
 
 ////// OS //////
diff --git a/core/core_bind.h b/core/core_bind.h
index 99e14a75f5..c116ac4986 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -109,7 +109,7 @@ public:
 
 	static ResourceSaver *get_singleton() { return singleton; }
 
-	Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags);
+	Error save(const String &p_path, const Ref<Resource> &p_resource, BitField<SaverFlags> p_flags);
 	Vector<String> get_recognized_extensions(const Ref<Resource> &p_resource);
 	void add_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver, bool p_at_front);
 	void remove_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver);
@@ -719,7 +719,7 @@ public:
 VARIANT_ENUM_CAST(core_bind::ResourceLoader::ThreadLoadStatus);
 VARIANT_ENUM_CAST(core_bind::ResourceLoader::CacheMode);
 
-VARIANT_ENUM_CAST(core_bind::ResourceSaver::SaverFlags);
+VARIANT_BITFIELD_CAST(core_bind::ResourceSaver::SaverFlags);
 
 VARIANT_ENUM_CAST(core_bind::OS::VideoDriver);
 VARIANT_ENUM_CAST(core_bind::OS::Weekday);
diff --git a/core/doc_data.cpp b/core/doc_data.cpp
index 1e72ad1090..89e7a8dc71 100644
--- a/core/doc_data.cpp
+++ b/core/doc_data.cpp
@@ -38,7 +38,7 @@ void DocData::return_doc_from_retinfo(DocData::MethodDoc &p_method, const Proper
 		} else {
 			p_method.return_type += "*";
 		}
-	} else if (p_retinfo.type == Variant::INT && p_retinfo.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+	} else if (p_retinfo.type == Variant::INT && p_retinfo.usage & (PROPERTY_USAGE_CLASS_IS_ENUM | PROPERTY_USAGE_CLASS_IS_BITFIELD)) {
 		p_method.return_enum = p_retinfo.class_name;
 		if (p_method.return_enum.begins_with("_")) { //proxy class
 			p_method.return_enum = p_method.return_enum.substr(1, p_method.return_enum.length());
@@ -69,7 +69,7 @@ void DocData::argument_doc_from_arginfo(DocData::ArgumentDoc &p_argument, const
 		} else {
 			p_argument.type += "*";
 		}
-	} else if (p_arginfo.type == Variant::INT && p_arginfo.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+	} else if (p_arginfo.type == Variant::INT && p_arginfo.usage & (PROPERTY_USAGE_CLASS_IS_ENUM | PROPERTY_USAGE_CLASS_IS_BITFIELD)) {
 		p_argument.enumeration = p_arginfo.class_name;
 		if (p_argument.enumeration.begins_with("_")) { //proxy class
 			p_argument.enumeration = p_argument.enumeration.substr(1, p_argument.enumeration.length());
diff --git a/core/doc_data.h b/core/doc_data.h
index af20b717d7..6fd01b0c52 100644
--- a/core/doc_data.h
+++ b/core/doc_data.h
@@ -103,6 +103,7 @@ public:
 		String value;
 		bool is_value_valid = false;
 		String enumeration;
+		bool is_bitfield = false;
 		String description;
 		bool operator<(const ConstantDoc &p_const) const {
 			return name < p_const.name;
@@ -111,6 +112,7 @@ public:
 
 	struct EnumDoc {
 		String name = "@unnamed_enum";
+		bool is_bitfield = false;
 		String description;
 		Vector<DocData::ConstantDoc> values;
 	};
diff --git a/core/extension/extension_api_dump.cpp b/core/extension/extension_api_dump.cpp
index 9d846f87c2..d5c49b01e9 100644
--- a/core/extension/extension_api_dump.cpp
+++ b/core/extension/extension_api_dump.cpp
@@ -46,7 +46,7 @@ static String get_type_name(const PropertyInfo &p_info) {
 			return p_info.hint_string + "*";
 		}
 	}
-	if (p_info.type == Variant::INT && (p_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM)) {
+	if (p_info.type == Variant::INT && (p_info.usage & (PROPERTY_USAGE_CLASS_IS_ENUM | PROPERTY_USAGE_CLASS_IS_BITFIELD))) {
 		return String("enum::") + String(p_info.class_name);
 	}
 	if (p_info.class_name != StringName()) {
@@ -665,6 +665,7 @@ Dictionary NativeExtensionAPIDump::generate_extension_api() {
 				for (const StringName &F : enum_list) {
 					Dictionary d2;
 					d2["name"] = String(F);
+					d2["is_bitfield"] = ClassDB::is_enum_bitfield(class_name, F);
 
 					Array values;
 					List<StringName> enum_constant_list;
diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp
index 3c9f373d12..ac008dad88 100644
--- a/core/object/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -536,7 +536,7 @@ MethodBind *ClassDB::get_method(const StringName &p_class, const StringName &p_n
 	return nullptr;
 }
 
-void ClassDB::bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int64_t p_constant) {
+void ClassDB::bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int64_t p_constant, bool p_is_bitfield) {
 	OBJTYPE_WLOCK;
 
 	ClassInfo *type = classes.getptr(p_class);
@@ -555,13 +555,15 @@ void ClassDB::bind_integer_constant(const StringName &p_class, const StringName
 			enum_name = enum_name.get_slicec('.', 1);
 		}
 
-		List<StringName> *constants_list = type->enum_map.getptr(enum_name);
+		ClassInfo::EnumInfo *constants_list = type->enum_map.getptr(enum_name);
 
 		if (constants_list) {
-			constants_list->push_back(p_name);
+			constants_list->constants.push_back(p_name);
+			constants_list->is_bitfield = p_is_bitfield;
 		} else {
-			List<StringName> new_list;
-			new_list.push_back(p_name);
+			ClassInfo::EnumInfo new_list;
+			new_list.is_bitfield = p_is_bitfield;
+			new_list.constants.push_back(p_name);
 			type->enum_map[enum_name] = new_list;
 		}
 	}
@@ -645,8 +647,8 @@ StringName ClassDB::get_integer_constant_enum(const StringName &p_class, const S
 	ClassInfo *type = classes.getptr(p_class);
 
 	while (type) {
-		for (KeyValue<StringName, List<StringName>> &E : type->enum_map) {
-			List<StringName> &constants_list = E.value;
+		for (KeyValue<StringName, ClassInfo::EnumInfo> &E : type->enum_map) {
+			List<StringName> &constants_list = E.value.constants;
 			const List<StringName>::Element *found = constants_list.find(p_name);
 			if (found) {
 				return E.key;
@@ -669,7 +671,7 @@ void ClassDB::get_enum_list(const StringName &p_class, List<StringName> *p_enums
 	ClassInfo *type = classes.getptr(p_class);
 
 	while (type) {
-		for (KeyValue<StringName, List<StringName>> &E : type->enum_map) {
+		for (KeyValue<StringName, ClassInfo::EnumInfo> &E : type->enum_map) {
 			p_enums->push_back(E.key);
 		}
 
@@ -687,10 +689,10 @@ void ClassDB::get_enum_constants(const StringName &p_class, const StringName &p_
 	ClassInfo *type = classes.getptr(p_class);
 
 	while (type) {
-		const List<StringName> *constants = type->enum_map.getptr(p_enum);
+		const ClassInfo::EnumInfo *constants = type->enum_map.getptr(p_enum);
 
 		if (constants) {
-			for (const List<StringName>::Element *E = constants->front(); E; E = E->next()) {
+			for (const List<StringName>::Element *E = constants->constants.front(); E; E = E->next()) {
 				p_constants->push_back(E->get());
 			}
 		}
@@ -748,6 +750,25 @@ bool ClassDB::has_enum(const StringName &p_class, const StringName &p_name, bool
 	return false;
 }
 
+bool ClassDB::is_enum_bitfield(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) {
+	OBJTYPE_RLOCK;
+
+	ClassInfo *type = classes.getptr(p_class);
+
+	while (type) {
+		if (type->enum_map.has(p_name) && type->enum_map[p_name].is_bitfield) {
+			return true;
+		}
+		if (p_no_inheritance) {
+			return false;
+		}
+
+		type = type->inherits_ptr;
+	}
+
+	return false;
+}
+
 void ClassDB::add_signal(const StringName &p_class, const MethodInfo &p_signal) {
 	OBJTYPE_WLOCK;
 
diff --git a/core/object/class_db.h b/core/object/class_db.h
index f2f73dc674..1d26eb18f1 100644
--- a/core/object/class_db.h
+++ b/core/object/class_db.h
@@ -104,7 +104,12 @@ public:
 
 		HashMap<StringName, MethodBind *> method_map;
 		HashMap<StringName, int64_t> constant_map;
-		HashMap<StringName, List<StringName>> enum_map;
+		struct EnumInfo {
+			List<StringName> constants;
+			bool is_bitfield = false;
+		};
+
+		HashMap<StringName, EnumInfo> enum_map;
 		HashMap<StringName, MethodInfo> signal_map;
 		List<PropertyInfo> property_list;
 		HashMap<StringName, PropertyInfo> property_map;
@@ -325,15 +330,17 @@ public:
 	static void add_virtual_method(const StringName &p_class, const MethodInfo &p_method, bool p_virtual = true, const Vector<String> &p_arg_names = Vector<String>(), bool p_object_core = false);
 	static void get_virtual_methods(const StringName &p_class, List<MethodInfo> *p_methods, bool p_no_inheritance = false);
 
-	static void bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int64_t p_constant);
+	static void bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int64_t p_constant, bool p_is_bitfield = false);
 	static void get_integer_constant_list(const StringName &p_class, List<String> *p_constants, bool p_no_inheritance = false);
 	static int64_t get_integer_constant(const StringName &p_class, const StringName &p_name, bool *p_success = nullptr);
 	static bool has_integer_constant(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 
 	static StringName get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
+	static StringName get_integer_constant_bitfield(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 	static void get_enum_list(const StringName &p_class, List<StringName> *p_enums, bool p_no_inheritance = false);
 	static void get_enum_constants(const StringName &p_class, const StringName &p_enum, List<StringName> *p_constants, bool p_no_inheritance = false);
 	static bool has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
+	static bool is_enum_bitfield(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 
 	static void set_method_error_return_values(const StringName &p_class, const StringName &p_method, const Vector<Error> &p_values);
 	static Vector<Error> get_method_error_return_values(const StringName &p_class, const StringName &p_method);
@@ -370,6 +377,9 @@ public:
 #define BIND_ENUM_CONSTANT(m_constant) \
 	::ClassDB::bind_integer_constant(get_class_static(), __constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
 
+#define BIND_BITFIELD_FLAG(m_constant) \
+	::ClassDB::bind_integer_constant(get_class_static(), __constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
+
 _FORCE_INLINE_ void errarray_add_str(Vector<Error> &arr) {
 }
 
@@ -401,6 +411,9 @@ _FORCE_INLINE_ Vector<Error> errarray(P... p_args) {
 #define BIND_ENUM_CONSTANT(m_constant) \
 	::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant);
 
+#define BIND_BITFIELD_FLAG(m_constant) \
+	::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant, true);
+
 #define BIND_METHOD_ERR_RETURN_DOC(m_method, ...)
 
 #endif
diff --git a/core/object/object.h b/core/object/object.h
index 1f6386e6b4..87d042dd7e 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -109,6 +109,7 @@ enum PropertyUsageFlags {
 	PROPERTY_USAGE_GROUP = 128, //used for grouping props in the editor
 	PROPERTY_USAGE_CATEGORY = 256,
 	PROPERTY_USAGE_SUBGROUP = 512,
+	PROPERTY_USAGE_CLASS_IS_BITFIELD = 1024,
 	PROPERTY_USAGE_NO_INSTANCE_STATE = 2048,
 	PROPERTY_USAGE_RESTART_IF_CHANGED = 4096,
 	PROPERTY_USAGE_SCRIPT_VARIABLE = 8192,
diff --git a/core/variant/binder_common.h b/core/variant/binder_common.h
index 22a13b0fab..84f894dcbf 100644
--- a/core/variant/binder_common.h
+++ b/core/variant/binder_common.h
@@ -106,6 +106,29 @@ struct VariantCaster<const T &> {
 		static void initialize(m_enum &value) { value = (m_enum)0; }         \
 	};
 
+#define VARIANT_BITFIELD_CAST(m_enum)                                                  \
+	MAKE_BITFIELD_TYPE_INFO(m_enum)                                                    \
+	template <>                                                                        \
+	struct VariantCaster<BitField<m_enum>> {                                           \
+		static _FORCE_INLINE_ BitField<m_enum> cast(const Variant &p_variant) {        \
+			return BitField<m_enum>(p_variant.operator int64_t());                     \
+		}                                                                              \
+	};                                                                                 \
+	template <>                                                                        \
+	struct PtrToArg<BitField<m_enum>> {                                                \
+		_FORCE_INLINE_ static BitField<m_enum> convert(const void *p_ptr) {            \
+			return BitField<m_enum>(*reinterpret_cast<const int64_t *>(p_ptr));        \
+		}                                                                              \
+		typedef int64_t EncodeT;                                                       \
+		_FORCE_INLINE_ static void encode(BitField<m_enum> p_val, const void *p_ptr) { \
+			*(int64_t *)p_ptr = p_val;                                                 \
+		}                                                                              \
+	};                                                                                 \
+	template <>                                                                        \
+	struct ZeroInitializer<BitField<m_enum>> {                                         \
+		static void initialize(BitField<m_enum> &value) { value = 0; }                 \
+	};
+
 // Object enum casts must go here
 VARIANT_ENUM_CAST(Object::ConnectFlags);
 
diff --git a/core/variant/type_info.h b/core/variant/type_info.h
index bacd0d19ce..794274dd77 100644
--- a/core/variant/type_info.h
+++ b/core/variant/type_info.h
@@ -279,6 +279,51 @@ inline StringName __constant_get_enum_name(T param, const String &p_constant) {
 	return GetTypeInfo<T>::get_class_info().class_name;
 }
 
+template <class T>
+class BitField {
+	uint32_t value = 0;
+
+public:
+	_FORCE_INLINE_ void set_flag(T p_flag) { value |= p_flag; }
+	_FORCE_INLINE_ bool has_flag(T p_flag) const { return value & p_flag; }
+	_FORCE_INLINE_ void clear_flag(T p_flag) { return value &= ~p_flag; }
+	_FORCE_INLINE_ BitField(uint32_t p_value) { value = p_value; }
+	_FORCE_INLINE_ operator uint32_t() const { return value; }
+};
+
+#define TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, m_impl)                                                                                            \
+	template <>                                                                                                                                  \
+	struct GetTypeInfo<m_impl> {                                                                                                                 \
+		static const Variant::Type VARIANT_TYPE = Variant::INT;                                                                                  \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;                                                            \
+		static inline PropertyInfo get_class_info() {                                                                                            \
+			return PropertyInfo(Variant::INT, String(), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_CLASS_IS_BITFIELD, \
+					godot::details::enum_qualified_name_to_class_info_name(String(#m_enum)));                                                    \
+		}                                                                                                                                        \
+	};                                                                                                                                           \
+	template <>                                                                                                                                  \
+	struct GetTypeInfo<BitField<m_impl>> {                                                                                                       \
+		static const Variant::Type VARIANT_TYPE = Variant::INT;                                                                                  \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;                                                            \
+		static inline PropertyInfo get_class_info() {                                                                                            \
+			return PropertyInfo(Variant::INT, String(), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_CLASS_IS_BITFIELD, \
+					godot::details::enum_qualified_name_to_class_info_name(String(#m_enum)));                                                    \
+		}                                                                                                                                        \
+	};
+
+#define MAKE_BITFIELD_TYPE_INFO(m_enum)                 \
+	TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, m_enum)       \
+	TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, m_enum const) \
+	TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, m_enum &)     \
+	TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, const m_enum &)
+
+template <typename T>
+inline StringName __constant_get_bitfield_name(T param, const String &p_constant) {
+	if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) {
+		ERR_PRINT("Missing VARIANT_ENUM_CAST for constant's bitfield: " + p_constant);
+	}
+	return GetTypeInfo<BitField<T>>::get_class_info().class_name;
+}
 #define CLASS_INFO(m_type) (GetTypeInfo<m_type *>::get_class_info())
 
 template <typename T>