rebuild refl

engine/3rdparty/zlib/include/refl/detail/any.h

@@ -0,0 +1,60 @@
+#pragma once
+#include "type.h"
+namespace refl {
+	class UClass;
+	//生命周期短，适用于传参，不建议保存数据
+	//只能指向指针，引用=>指针，指针=>指针，T => T*,T的类型丢失
+	struct Any {
+	public:
+		const void* ptr;
+		const UClass* cls;
+		constexpr Any(const void* ptr,const UClass* cls) : ptr(ptr), cls(cls) {}
+		constexpr Any() : ptr(nullptr), cls(nullptr) {}
+		//右值=>右值压入栈，caller入栈地址
+		//左值=>caller变量地址
+		template<typename T>
+		constexpr Any(T&& v) : ptr(&v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
+			if constexpr (std::is_same_v<args_type_t<T>, Any>) {
+				ptr = v.ptr;
+				cls = v.cls;
+			}
+		}
+		template<typename T>
+		constexpr Any(T* v) : ptr(v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
+			if constexpr (std::is_same_v<args_type_t<T>, Any>) {
+				ptr = v->ptr;
+				cls = v->cls;
+			}
+		}
+		template<typename T>//参数 T* => T*
+		constexpr inline T cast_to() const {
+			if constexpr (std::is_pointer_v<T>) {
+				return (T)ptr;
+			}
+			else if constexpr (std::is_reference_v<T>) {
+				using RT = std::remove_reference_t<T>;
+				return *(RT*)ptr;
+			}
+			else {
+				return *(T*)ptr;
+			}
+		}
+		template<typename T>
+		T cast_ret() const {
+			if constexpr (std::is_pointer_v<T>) {
+				return *(T*)ptr;
+			}
+			else if constexpr (std::is_reference_v<T>) {
+				using RT = std::remove_reference_t<T>;
+				return **(RT**)ptr;
+			}
+			else {
+				return *(T*)ptr;
+			}
+		}
+		Any* ConvertTo(const UClass* toClass);
+		constexpr bool IsValid() const{
+			return cls != nullptr && ptr != nullptr;
+		}
+	};
+}

engine/3rdparty/zlib/include/refl/detail/field.h

@@ -1,21 +1,29 @@
 #pragma once
 #include "UTemplate/Type.hpp"
 #include "../std/sarray.h"
+#include "any.h"
 #include <variant>
 #include <functional>
 using Ubpa::Name;
 using Ubpa::type_name;
 namespace refl {
-	class UClass;
-	class ArgsView;
-	class ArgsValue;
-
 	using Offset = uint32_t;
 	using Method = void*;
 
-	using DefaultMember = const ArgsView (*)();
+	struct MemberData {
-	using DefaultMethod = std::pair<ArgsView*, int>(*)();
+		Offset offset;
-
+		Any value;
+		Any meta;
+		constexpr MemberData() :offset(0), value(), meta() {}
+		constexpr MemberData(Offset offset,const Any& value,const Any& meta) : offset(offset), value(value), meta(meta) {}
+	};
+	struct MethodData {
+		Method fptr;
+		sarray<Any> value;
+		Any meta;
+		constexpr MethodData() :fptr(nullptr), value(), meta() {}
+		constexpr MethodData(Method fptr,const sarray<Any>& value, const Any& meta) : fptr(fptr), value(value), meta(meta) {}
+	};
 	enum FieldFlag:uint32_t {
 		FIELD_NONE_FLAG				= 0,
 		FIELD_MEMBER_FLAG			= 1 << 0,
@@ -27,99 +35,28 @@ namespace refl {
 	struct FieldPtr {
 		union Data
 		{
-			Offset offset;
+			MemberData member;
-			Method method;
+			MethodData method;
-			constexpr Data() : method(nullptr) {}
+			constexpr Data() : member() {};
-			constexpr Data(Offset& offset) : offset(offset) {}
+			constexpr Data(const MemberData& member) :member(member) {}
-			constexpr Data(Method& method) : method(method) {}
+			constexpr Data(const MethodData& method) : method(method) {}
-			constexpr Data(const Method& method) : method(method) {}
+			constexpr Data(Offset offset) :member(offset, {}, {}) {}
-		};
+			constexpr Data(Offset offset, const Any& value, const Any& meta):member(offset, value, meta){}
-		union Default {
+			constexpr Data(Method fptr, const sarray<Any>& value, const Any& meta) : method(fptr, value, meta) {}
-			DefaultMember member;
-			DefaultMethod method;
-			constexpr Default(): method(nullptr) {}
-			constexpr Default(DefaultMember& member) : member(member) {}
-			constexpr Default(DefaultMethod& method) : method(method) {}
 		};
 		Name name;
 		const UClass* type{};
 		Data data{};
-		Default value{};
 		uint32_t flag{};
 		
 		//unsafe
-		bool Invoke(const sarray<ArgsView>& ArgsList)const;
+		bool Invoke(const sarray<Any>& ArgsList)const;
 		//safe
-		bool Invoke(svector<ArgsView>& ArgsList)const;
+		bool Invoke(svector<Any>& ArgsList)const;
 
 		template<typename Func, typename... Args>
 		auto Call(Func func, Args&&... args)const;
 
 		sarray<const UClass*> GetParams() const;
 	};
-	template<typename T, typename R, typename ...Args>
-	consteval auto fetch_method_t(R(T::*)(Args...)) {
-		using MethodType = R(*)(const void*, Args...);
-		return MethodType{ nullptr };
-	}
-	template<typename R, typename ...Args>
-	consteval auto fetch_method_t(R(*)(Args...)) {
-		using MethodType = R(*)(Args...);
-		return MethodType{ nullptr };
-	}
-	template<typename T>
-	consteval int fetch_args_size() {
-		auto fields = T::__MakeStaticFields();
-		int size = 0;
-		for (auto& field : fields) {
-			size += field.data.offset;
-		}
-		return size;
-	}
-	template<typename T>
-	class Field;
-	/*
-	template<typename T, typename V>
-	consteval V* fetch_member_v(V T::*) {
-		return nullptr;
-	}
-	template<typename R, typename T, typename ...Args>
-	consteval auto fetch_method_v(R (T::* ptr)(Args...)) {
-		using MethodType = R(*)(T*, Args...);
-		return MethodType{nullptr};
-	}
-	template<typename R, typename ...Args>
-	consteval auto fetch_method_v(R(*ptr)(Args...)) {
-		return ptr;
-	}
-	template<typename... Args>
-	consteval auto FetchMembers(const std::tuple<Args...>&) {
-		return std::make_tuple(fetch_member_v(Args{nullptr})...);
-	}
-	template<typename... Args>
-	consteval auto FetchMethods(const std::tuple<Args...>&) {
-		return std::make_tuple(fetch_method_v(Args{ nullptr })...);
-	}
-	template<typename ...Args>
-	class FieldMembers{
-	public:
-		constexpr FieldMembers() {}
-		FieldMembers(const std::tuple<Args*...>&) {
-
-		}
-		constexpr static int GetSize() {
-			return sizeof...(Args);
-		}
-	};
-	template<typename ...Args>
-	class FieldMethods{
-	public:
-		constexpr FieldMethods() {}
-		FieldMethods(const std::tuple<Args*...>&) {
-
-		}
-		constexpr static int GetSize() {
-			return sizeof...(Args);
-		}
-	};*/
 }

engine/3rdparty/zlib/include/refl/detail/field.inl

@@ -4,24 +4,25 @@ namespace refl {
 	inline auto FieldPtr::Call(Func func, Args&& ...args)const
 	{
 		using MemberFunc = decltype(fetch_method_t(func));
-		MemberFunc fptr = (MemberFunc)data.method;
+		MemberFunc fptr = (MemberFunc)data.method.fptr;
 		return fptr(std::forward<Args>(args)...);
 	}
-	bool FieldPtr::Invoke(const sarray<ArgsView>& ArgsList)const{
+	bool FieldPtr::Invoke(const sarray<Any>& ArgsList)const{
 		auto Call = type->vtable.Call;
 		if (Call) {
 			Call(this, ArgsList);
 		}
 		return Call;
 	}
-	bool FieldPtr::Invoke(svector<ArgsView>& ArgsList)const {
+	bool FieldPtr::Invoke(svector<Any>& ArgsList)const {
 		auto Call = type->vtable.Call;
 		if (Call) {
-			auto params = GetParams();
+			sarray<const UClass*> params = GetParams();
 			int paramsSize = params.size();
 			int argsSize = ArgsList.size();
 			if (argsSize < paramsSize && flag & FIELD_METHOD_VALUE_FLAG) {
-				auto [argsPtr, valueSize] = value.method();
+				const Any* argsPtr = data.method.value.front();
+				int valueSize = data.method.value.size();
 				if (argsSize + valueSize >= paramsSize) {
 					for (int i = valueSize + argsSize - paramsSize; i < valueSize; i++) {
 						ArgsList.push_back(*(argsPtr + i));
@@ -32,8 +33,7 @@ namespace refl {
 			if (argsSize < paramsSize) {
 				return false;
 			}
-
+			Any* a = ArgsList.front();
-			auto a = ArgsList.front();
 			auto p = params.front();
 			for (auto e = params.back(); p < e; ++p, ++a) {
 				if (a->cls != *p && !a->ConvertTo(*p)) {
@@ -51,49 +51,4 @@ namespace refl {
 		}
 		return{};
 	}
-	template<typename T>
-	class Field {
-	public:
-		inline static char s_data[fetch_args_size<T>()]{};
-		inline static int s_index{0};
-		template<typename V>
-		static FieldPtr MakeField(V T::* ptr, Name name)
-		{
-			FieldPtr::Default value;
-			Offset offset = reinterpret_cast<std::size_t>(&(reinterpret_cast<const T*>(0)->*ptr));
-			FieldPtr::Data member = { offset };
-			constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
-			return { name, &TypeInfo<V>::StaticClass, member, value, flag };
-		}
-		template<typename R, typename ...Args>
-		static FieldPtr MakeField(R(*ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
-			uint32_t flag = FIELD_METHOD_FLAG;
-			FieldPtr::Default value;
-			if (args.size() > 0) {
-				flag |= FIELD_METHOD_VALUE_FLAG;
-				static const ArgsValueList argsValue(args, &Field<T>::s_data[Field<T>::s_index]);
-				Field<T>::s_index += ArgsValueList::GetArgsSize(args);
-				value.method = []() ->std::pair<ArgsView*, int> {
-					return { argsValue.ptr , argsValue.num };
-				};
-			}
-			FieldPtr::Data method = { *(Method*)&ptr };
-			return { name, &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass, method, value, flag };
-		}
-		template<typename R, typename ...Args>
-		static FieldPtr MakeField(R(T::* ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
-			uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
-			FieldPtr::Default value;
-			if (args.size() > 0) {
-				flag |= FIELD_METHOD_VALUE_FLAG;
-				static const ArgsValueList argsValue(args, &s_data[s_index]);
-				s_index += ArgsValueList::GetArgsSize(args);
-				value.method = []() ->std::pair<ArgsView*, int> {
-					return { argsValue.ptr , argsValue.num };
-				};
-			}
-			FieldPtr::Data method = { *(Method*)&ptr };
-			return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass, method, value,flag };
-		}
-	};
 }

engine/3rdparty/zlib/include/refl/detail/meta.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "field.h"
+namespace refl {
+	template<typename T, typename R, typename ...Args>
+	consteval auto fetch_method_t(R(T::*)(Args...)) {
+		using MethodType = R(*)(const void*, Args...);
+		return MethodType{ nullptr };
+	}
+	template<typename R, typename ...Args>
+	consteval auto fetch_method_t(R(*)(Args...)) {
+		using MethodType = R(*)(Args...);
+		return MethodType{ nullptr };
+	}
+	template<typename T>
+	consteval int fetch_meta_size() {
+		auto fields = T::__MakeStaticFields();
+		int size = 0;
+		for (auto& field : fields) {
+			size += field.data.member.offset;
+		}
+		return size;
+	}
+	enum MetaFlag :uint32_t {
+		META_NONE_FLAG = 0,
+		META_SERIZLE_FLAG = 1 << 0,
+		META_UI_FLAG = 1 << 0,
+	};
+	class UClass;
+	class MemberDataValue;
+	class MethodDataValue;
+	class Meta {
+	public:
+		UClass* cls;
+		uint32_t flag{ 0 };
+
+		template<typename T, typename Obj>
+		static FieldPtr MemberField(T Obj::* ptr, const Name& name, char*& memory, const MemberDataValue& data = {});
+
+		template<typename R, typename ...Args>
+		static FieldPtr MethodField(R(*ptr)(Args...), const Name& name,char*& memory, const MethodDataValue& data = {});
+
+		template<typename T,typename R, typename ...Args>
+		static FieldPtr MethodField(R(T::*ptr)(Args...), const Name& name,char*& memory, const MethodDataValue& data = {});
+	};
+}

engine/3rdparty/zlib/include/refl/detail/meta.inl

@@ -0,0 +1,70 @@
+#pragma once
+#include "meta.h"
+#include "uclass.h"
+namespace refl {
+
+	template<typename T, typename Obj>
+	inline FieldPtr Meta::MemberField(T Obj::* ptr, const Name& name, char*& memory, const MemberDataValue& data)
+	{
+		MemberData member;
+		member.offset = reinterpret_cast<std::size_t>(&(reinterpret_cast<const Obj*>(0)->*ptr));
+		if (AnyValue arg = data.value; arg.IsValid()) {
+			arg.type->InitObject(memory);
+			arg.type->CopyObject(memory, arg.ptr);
+			member.value = Any(memory, arg.cls).ConvertTo(&TypeInfo<real_type_t<T>*>::StaticClass);
+			memory += arg.type->size;
+		}
+		if (AnyValue arg = data.meta; arg.IsValid()) {
+			arg.type->InitObject(memory);
+			arg.type->CopyObject(memory, arg.ptr);
+			member.meta = Any(memory, arg.cls);
+			memory += arg.type->size;
+		}
+		constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
+		return { name, &TypeInfo<T>::StaticClass, member,flag};
+	}
+	template<typename R, typename ...Args>
+	inline FieldPtr Meta::MethodField(R(*ptr)(Args...), const Name& name, char*& memory, const MethodDataValue& data)
+	{
+		MethodData method;
+		uint32_t flag = FIELD_METHOD_FLAG;
+		auto cls = &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass;
+		if (auto& args = data.value; !args.empty()) {
+			flag |= FIELD_METHOD_VALUE_FLAG;
+			AnyValueList argsValue(args, memory);
+			argsValue.ConvertArgs(cls->vtable.GetParams(cls));
+			method.value = argsValue.ToSArray();
+			memory += AnyValueList::GetArgsSize(args);
+		}
+		if (AnyValue arg = data.meta; arg.IsValid()) {
+			arg.type->InitObject(memory);
+			arg.type->CopyObject(memory, arg.ptr);
+			method.meta = Any(memory, arg.cls);
+			memory += arg.type->size;
+		}
+		method.fptr = { *(Method*)&ptr };
+		return { name, cls, method,flag };
+	}
+	template<typename T, typename R, typename ...Args>
+	inline FieldPtr Meta::MethodField(R(T::*ptr)(Args...),const Name& name, char*& memory, const MethodDataValue& data)
+	{
+		MethodData method;
+		uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
+		auto cls = &TypeInfo<real_type_t<R>(*)(const void*, real_type_t<Args>...)>::StaticClass;
+		if (auto& args = data.value; !args.empty()) {
+			flag |= FIELD_METHOD_VALUE_FLAG;
+			AnyValueList argsValue(args, memory);
+			argsValue.ConvertArgs(cls->vtable.GetParams(cls));
+			method.value = argsValue.ToSArray();
+			memory += AnyValueList::GetArgsSize(args);
+		}
+		if (AnyValue arg = data.meta; arg.IsValid()) {
+			arg.type->InitObject(memory);
+			arg.type->CopyObject(memory, arg.ptr);
+			method.meta = Any(memory, arg.cls);
+			memory += arg.type->size;
+		}
+		method.fptr = { *(Method*)&ptr };
+		return { name, cls, method,flag };
+	}
+}

engine/3rdparty/zlib/include/refl/detail/type.h

@@ -1,10 +1,13 @@
 #pragma once
 #include <type_traits>
 namespace refl {
+	template <class T>
+	concept _ReflCheck_Meta = requires { typename T::MyStatic; typename T::MyUClass;};
+
 	template <class T>
 	concept _ReflCheck_Ctor = requires { T(); };
 	template <class T>
-	concept _ReflCheck_UClass = requires { !std::is_void_v<decltype(T::__MakeFields())>; };
+	concept _ReflCheck_UClass = _ReflCheck_Meta<typename T::MyMeta>;
 	template <class T>
 	concept _ReflCheck_Ctor_NoUClass = _ReflCheck_Ctor<T> && !_ReflCheck_UClass<T>;
 
@@ -34,6 +37,7 @@ namespace refl {
 	struct real_type<T*> {
 		using type = std::remove_cv_t<T>*;
 	};
+
 	template<typename T>
 	using real_type_t = real_type<T>::type;
 

engine/3rdparty/zlib/include/refl/detail/uclass.h

@@ -1,7 +1,7 @@
 #pragma once
-#include "type.h"
 #include "field.h"
 #include "view.h"
+#include "meta.h"
 namespace refl {
 	enum ClassFlag :uint32_t {
 		CLASS_NONE_FLAG = 0,
@@ -15,7 +15,7 @@ namespace refl {
 		//function
 		sarray<const UClass*>(*GetParams)(const UClass*);
 		//function
-		void (*Call)(const FieldPtr*, const sarray<ArgsView>& ArgsList);
+		void (*Call)(const FieldPtr*, const sarray<Any>& ArgsList);
 
 		//object
 		void (*InitObject)(void*);
@@ -28,11 +28,12 @@ namespace refl {
 		uint32_t size;
 		uint32_t flag{0};
 		const UClass* parent;
+		Meta* meta{nullptr};
 		vtable_uclass vtable{};
 	public:
 		constexpr UClass(std::string_view name, uint32_t size, const UClass* parent = nullptr)
 			:name(name), size(size), parent(parent){}
-		ObjectView New(void* ptr = nullptr) const{
+		AnyView New(void* ptr = nullptr) const{
 			if (ptr == nullptr) {
 				ptr = malloc(size);
 				InitObject(ptr);

engine/3rdparty/zlib/include/refl/detail/uclass.inl

@@ -48,19 +48,19 @@ namespace refl {
 		//这里顺序似乎是不确定的，但是我实际运用是对的
 		//如果使用make_index_sequence,会多一次函数调用
 		//为什么包裹一层迭代器，就不会出现警告了
-		static void Call(const FieldPtr* field, const sarray<ArgsView>& ArgsList) {
+		static void Call(const FieldPtr* field, const sarray<Any>& ArgsList) {
 			assert(sizeof...(Args) <= ArgsList.size());
 			if constexpr (std::is_same_v<R, void>) {
-				MethodType fptr = (MethodType)field->data.method;
+				MethodType fptr = (MethodType)field->data.method.fptr;
 				auto param = ArgsList.end();
 				fptr((param--->cast_to<Args>())...);
 			}
 			else {
-				MethodType fptr = (MethodType)field->data.method;
+				MethodType fptr = (MethodType)field->data.method.fptr;
 				auto param = ArgsList.end();
 				auto ret = ArgsList.front();
 				if (ret->cls == &TypeInfo<R*>::StaticClass) {
-					*(R*)ret->val = fptr((param--->cast_to<Args>())...);
+					*(R*)ret->ptr = fptr((param--->cast_to<Args>())...);
 				}
 				else {
 					fptr((param--->cast_to<Args>())...);
@@ -91,8 +91,8 @@ namespace refl {
 	template<typename T, typename P = void>
 	class UClass_Meta : public UClass {
 	public:
-		using FieldsType = decltype(T::__MakeFields());
+		using FieldsType = decltype(T::MyMeta::__MakeFields());
-		FieldsType Fields{ T::__MakeFields() };
+		FieldsType Fields{ T::MyMeta::__MakeFields() };
 		UClass_Meta() : UClass(type_name<T>().View(), sizeof(T)){
 			if constexpr (std::is_trivially_copyable_v<T>) {
 				flag = CLASS_TRIVIAL_FLAG;
@@ -140,7 +140,7 @@ namespace refl {
 	};
 	template<_ReflCheck_UClass T>
 	struct TypeInfoImpl<T> {
-		using MyUClass = typename T::MyUClass;
+		using MyUClass = typename T::MyMeta::MyUClass;
 		inline static MyUClass StaticClass = MyUClass();
 	};
 }

engine/3rdparty/zlib/include/refl/detail/view.h

@@ -1,77 +1,42 @@
 #pragma once
 #include <string>
-#include "type.h"
 #include "field.h"
 namespace refl {
-	class UClass;
-	class FieldPtr;
-	//生命周期短，适用于传参，不建议保存数据
-	//只能指向指针，引用=>指针，指针=>指针，T => T*,T的类型丢失
-	struct ArgsView {
-	public:
-		const void* val;
-		const UClass* cls;
-		constexpr ArgsView() : val(nullptr), cls(nullptr) {}
-		//右值=>右值压入栈，caller入栈地址
-		//左值=>caller变量地址
-		template<typename T>
-		constexpr ArgsView(T&& v): val(&v), cls(&TypeInfo<args_type_t<T>*>::StaticClass){
-			if constexpr (std::is_same_v<args_type_t<T>, ArgsView>) {
-				val = v.val;
-				cls = v.cls;
-			}
-		}
-		template<typename T>
-		constexpr ArgsView(T* v) : val(v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
-		}
-		template<typename T>//参数 T* => T*
-		constexpr inline T cast_to() const {
-			if constexpr (std::is_pointer_v<T>) {
-				return (T)val;
-			}
-			else if constexpr (std::is_reference_v<T>){
-				using RT = std::remove_reference_t<T>;
-				return *(RT*)val;
-			}else{
-				return *(T*)val;
-			}
-		}
-		template<typename T>
-		T cast_ret() const {
-			if constexpr (std::is_pointer_v<T>) {
-				return *(T*)val;
-			}
-			else if constexpr (std::is_reference_v<T>) {
-				using RT = std::remove_reference_t<T>;
-				return **(RT**)val;
-			}
-			else {
-				return *(T*)val;
-			}
-		}
-		bool ConvertTo(const UClass* toClass);
-	};
 	//存入的是真实的数据类型,type用于拷贝数据
-	struct ArgsValue : public ArgsView {
+	struct AnyValue : public Any {
 		const UClass* type;
+		constexpr AnyValue() :Any(), type(nullptr) {}
 		template<typename T>
-		constexpr ArgsValue(T&& t) : ArgsView(t), type(&TypeInfo<args_type_t<T>>::StaticClass){}
+		constexpr AnyValue(T&& t) : Any(t), type(&TypeInfo<args_type_t<T>>::StaticClass){}
 	};
-	struct ArgsValueList{
+	struct MemberDataValue {
+		Offset offset{0};
+		AnyValue value;
+		AnyValue meta;
+		constexpr MemberDataValue() :value(), meta() {}
+		constexpr MemberDataValue(const AnyValue& value, const AnyValue& meta = {}) : value(value), meta(meta) {}
+	};
+	struct MethodDataValue {
+		Method fptr{nullptr};
+		sarray<AnyValue> value;
+		AnyValue meta;
+		constexpr MethodDataValue() :value(), meta() {}
+		constexpr MethodDataValue(const sarray<AnyValue>& value, const AnyValue& meta = {}) : value(value), meta(meta) {}
+	};
+	struct AnyValueList{
 		void* data;
-		ArgsView* ptr;
 		int num;
 		bool isMemoryOwner{false};
-		ArgsValueList(const sarray<ArgsValue>& args,void* memory = nullptr);
+		AnyValueList(const sarray<AnyValue>& args,void* memory = nullptr);
-		~ArgsValueList();
+		~AnyValueList();
-		constexpr static int GetArgsSize(const sarray<ArgsValue>& args);
+		void ConvertArgs(sarray<const UClass*> params);
+		const sarray<Any> ToSArray();
+		constexpr static int GetArgsSize(const sarray<AnyValue>& args);
 	};
-	class ObjectView {
+	class AnyView : public Any{
 	public:
-		const void* ptr;
-		const UClass* cls;
 		const FieldPtr* cache{ nullptr };
-		ObjectView(const void* ptr, const UClass* cls) : ptr(ptr), cls(cls) {}
+		AnyView(const void* ptr, const UClass* cls) : Any(ptr,cls) {}
 	public:
 
 		template<typename T>
@@ -80,10 +45,10 @@ namespace refl {
 		template<typename T>
 		bool Set(const Name& name, const T& t);
 
-		bool Invoke(const Name& name,const sarray<ArgsView>& ArgsList);//这里是内存分配慢呀，这里是可以改成栈容器的
+		bool Invoke(const Name& name,const sarray<Any>& ArgsList);
 
-		bool Invoke(const Name& name,svector<ArgsView>& ArgsList);
+		bool Invoke(const Name& name,svector<Any>& ArgsList);
 
-		ObjectView Parent();
+		AnyView Parent();
 	};
 }

engine/3rdparty/zlib/include/refl/detail/view.inl

@@ -8,45 +8,49 @@ namespace refl {
 	* 对象从大到小
 	*/
 	using enum ClassFlag;
-	bool ArgsView::ConvertTo(const UClass* toClass) {
+	Any* Any::ConvertTo(const UClass* toClass) {
+		if (cls == toClass) {
+			return this;
+		}
 		//子类转父类
 		if (cls->IsChildOf(toClass)) {
 			cls = toClass;
-			return true;
+			return this;
 		}
 		if (cls->flag & CLASS_TRIVIAL_FLAG && toClass->flag & CLASS_TRIVIAL_FLAG) {
 			cls = toClass;
-			return true;
+			return this;
 		}
-		return false;
+		return nullptr;
 	}
-	ArgsValueList::ArgsValueList(const sarray<ArgsValue>& args, void* memory)
+	AnyValueList::AnyValueList(const sarray<AnyValue>& args, void* memory)
-		: ptr((ArgsView*)memory),data(memory), num(args.size())
+		: data(memory), num(args.size())
 	{
 		if (!memory) {
 			isMemoryOwner = true;
 			data = malloc(GetArgsSize(args));
-			ptr = (ArgsView*)data;
-			assert(data != nullptr);
 		}
-		char* pData = ((char*)data) + num * sizeof(ArgsView);
+		Any* any = (Any*)data;
+		assert(any != nullptr);
+		char* pData = ((char*)data) + num * sizeof(Any);
 		for (auto& arg : args) {
 			arg.type->InitObject(pData);
-			arg.type->CopyObject(pData, arg.val);
+			arg.type->CopyObject(pData, arg.ptr);
-			ptr->val = pData;
+			any->ptr = pData;
-			ptr->cls = arg.cls;
+			any->cls = arg.cls;
-			ptr++;
+			any++;
 			pData += arg.type->size;
 		}
-		ptr = (ArgsView*)data;
 	}
-	inline ArgsValueList::~ArgsValueList()
+	inline AnyValueList::~AnyValueList()
 	{
 		if (num == 0 || !data) {
 			return;
 		}
+		Any* ptr = (Any*)data;
 		for (int i = 0; i < num; i++) {
-			ptr->cls->DestObject((void*)ptr->val);
+			ptr->cls->DestObject((void*)ptr->ptr);
+			ptr++;
 		}
 		if (isMemoryOwner) {
 			free(data);
@@ -54,16 +58,28 @@ namespace refl {
 		num = 0;
 		data = nullptr;
 	}
-	inline constexpr int ArgsValueList::GetArgsSize(const sarray<ArgsValue>& args)
+	inline void AnyValueList::ConvertArgs(sarray<const UClass*> params)
 	{
-		int size = args.size() * sizeof(ArgsView);
+		Any* ptr = (Any*)data;
+		int first = params.size() - num;
+		for (int i = 0; i < num; i++, ptr++) {
+			ptr->ConvertTo(*params.at(first + i));
+		}
+	}
+	inline const sarray<Any> AnyValueList::ToSArray()
+	{
+		return sarray<Any>((Any*)data, num);
+	}
+	inline constexpr int AnyValueList::GetArgsSize(const sarray<AnyValue>& args)
+	{
+		int size = args.size() * sizeof(Any);
 		for (auto& arg : args) {
 			size += arg.type->size;
 		}
 		return size;
 	}
 	template<typename T>
-	inline bool ObjectView::Get(const Name& name, T& t)
+	inline bool AnyView::Get(const Name& name, T& t)
 	{
 		if (cache && cache->name == name) {
 		_cache_get: bool isChild = cache->type->IsChildOf<T>(true);
@@ -83,7 +99,7 @@ namespace refl {
 		return false;
 	}
 	template<typename T>
-	inline bool ObjectView::Set(const Name& name, const T& t)
+	inline bool AnyView::Set(const Name& name, const T& t)
 	{
 		if (cache && cache->name == name) {
 		_cache_set: bool isChild = cache->type->IsChildOf<T>(true);
@@ -102,7 +118,7 @@ namespace refl {
 		}
 		return false;
 	}
-	bool ObjectView::Invoke(const Name& name,const sarray<ArgsView>& ArgsList)
+	bool AnyView::Invoke(const Name& name,const sarray<Any>& ArgsList)
 	{
 		auto field = cls->GetField(name, 0);
 		if (!field) {
@@ -113,7 +129,7 @@ namespace refl {
 		}
 		return field->Invoke(ArgsList);
 	}
-	bool ObjectView::Invoke(const Name& name, svector<ArgsView>& ArgsList)
+	bool AnyView::Invoke(const Name& name, svector<Any>& ArgsList)
 	{
 		auto field = cls->GetField(name, 0);
 		if (!field) {
@@ -124,7 +140,7 @@ namespace refl {
 		}
 		return field->Invoke(ArgsList);
 	}
-	ObjectView ObjectView::Parent() {
+	AnyView AnyView::Parent() {
 		return { ptr, cls ? cls->parent : nullptr };
 	}
 }

engine/3rdparty/zlib/include/refl/macro.h

@@ -1,35 +1,3 @@
-#pragma once
+#if !defined(__cppast)
-/*
+#define __cppast(...)
-#define REGISTER_CLASS(cls) using _T = cls;
+#endif
-#define MAKE_STATIC_FIELD(member, ...) \
-    MakeStaticField(&_T::member, #member, __VA_ARGS__)
-
-#define MAKE_FIELD(member, ...) \
-    Field<_T>::MakeField(&_T::member, #member, __VA_ARGS__)
-
-#define REGISTER_FIELDS()\
-	consteval static auto __MakeStaticFields() {\
-		return std::array{\
-            MAKE_FIELD_LIST(MAKE_STATIC_FIELD)\
-        };\
-	}\
-	static auto __MakeFields() {\
-		return std::array{\
-            MAKE_FIELD_LIST(MAKE_FIELD)\
-        };\
-	}
-
-
-#define MAKE_FIELD_LIST(MACRO) \
-    MACRO(x), \
-    MACRO(y), \
-    MACRO(z), \
-    MACRO(norm, {10,9}), \
-    MACRO(norm1, {1}), \
-    MACRO(norm2,  {2}), 
-
-REGISTER_CLASS(vec3)
-REGISTER_FIELDS()
-
-#undef MAKE_FIELD_LIST
-*/

engine/3rdparty/zlib/include/refl/refl.h

@@ -2,37 +2,44 @@
 #include "detail/uclass.inl"
 #include "detail/view.inl"
 #include "detail/field.inl"
+#include "detail/meta.inl"
 #include "std/sarray.h"
 #include "macro.h"
 namespace refl {
 	template<typename T, typename Obj>
-	consteval FieldPtr MakeStaticField(T Obj::* ptr, Name name) {
+	consteval FieldPtr StaticMemberField(T Obj::* ptr, const Name& name, const MemberDataValue& data = {}) {
-		FieldPtr::Default value;
+		Offset offset = data.value.IsValid() ? sizeof(T) : 0;
-		Offset offset = 0;
+		if (data.meta.IsValid()) {
-		FieldPtr::Data member = { offset };
+			offset += data.meta.type->size;
+		}
+		FieldPtr::Data member(offset);
 		constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
-		return { name, &TypeInfo<T>::StaticClass, member, value, flag };
+		return { name,&TypeInfo<T>::StaticClass, member,flag};
 	}
 	template<typename R, typename ...Args>
-	consteval FieldPtr MakeStaticField(R(*ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
+	consteval FieldPtr StaticMethodField(R(*ptr)(Args...), const Name& name, const MethodDataValue& data = {}) {
 		uint32_t flag = FIELD_METHOD_FLAG;
-		FieldPtr::Default value;
+		Offset offset = AnyValueList::GetArgsSize(data.value);
-		Offset offset = ArgsValueList::GetArgsSize(args);
+		if (data.meta.IsValid()) {
-		FieldPtr::Data method = { offset };
+			offset += data.meta.type->size;
-		return { name, &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass, method, value, flag };
+		}
+		FieldPtr::Data method(offset);
+		return { name,&TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass,method, flag };
 	}
 	template<typename T, typename R, typename ...Args>
-	consteval FieldPtr MakeStaticField(R(T::* ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
+	consteval FieldPtr StaticMethodField(R(T::* ptr)(Args...), const Name& name, const MethodDataValue& data = {}) {
 		uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
-		FieldPtr::Default value;
+		Offset offset = AnyValueList::GetArgsSize(data.value);
-		Offset offset = ArgsValueList::GetArgsSize(args);
+		if (data.meta.IsValid()) {
-		FieldPtr::Data method = { offset };
+			offset += data.meta.type->size;
-		return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass, method, value,flag };
+		}
+		FieldPtr::Data method(offset);
+		return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass,method,flag };
 	}
 	//用处不大---------------begin
-	template<typename T>
+	template<_ReflCheck_Meta T>
-	consteval int GetStaticFieldID(Name name) {
+	consteval int GetStaticFieldID(const Name& name) {
-		auto fields = T::__MakeStaticFields();
+		auto fields = T::MyStatic::__MakeStaticFields();
 		auto first = fields.begin();
 		for (auto& field : fields) {
 			if (field.name == name) {
@@ -41,9 +48,9 @@ namespace refl {
 		}
 		return 0;
 	}
-	template<typename T>
+	template<_ReflCheck_Meta T>
 	consteval int GetStaticFieldID(bool(* fptr)(FieldPtr)) {
-		auto fields = T::__MakeStaticFields();
+		auto fields = T::MyStatic::__MakeStaticFields();
 		auto first = fields.begin();
 		for (auto& field : fields) {
 			if (fptr(field)) {
@@ -52,15 +59,15 @@ namespace refl {
 		}
 		return 0;
 	}
-	template<typename T, auto name>
+	template<_ReflCheck_Meta T, auto name>
 	consteval auto GetStaticField() {
-		constexpr auto fields = T::__StaticFields();
+		constexpr auto fields = T::MyMeta::__StaticFields();
 		using AutoType = decltype(name);
 		if constexpr (std::is_same_v<AutoType, int>) {
 			return std::get<name>(fields);
 		}
 		else {
-			constexpr auto id = GetStaticFieldID<T>(Name(name.Data()));
+			constexpr auto id = GetStaticFieldID<T>(name.Data());
 			return std::get<id>(fields);
 		}
 	}

engine/3rdparty/zlib/include/refl/std/sarray.h

@@ -24,6 +24,9 @@ namespace refl {
 			}
 			return nullptr;
 		}
+        constexpr bool empty() const noexcept {
+            return m_count == 0;
+        }
         constexpr int size() const noexcept {
 			return m_count;
 		}

engine/3rdparty/zlib/include/refl/std/svector.h

@@ -23,6 +23,9 @@ namespace refl {
                 m_count++;
             }
         }
+        constexpr bool empty() const noexcept {
+            return m_count == 0;
+        }
         constexpr int size() const noexcept {
             return m_count;
         }

engine/3rdparty/zlib/test/refl/vertex.h

@@ -9,11 +9,20 @@ struct vec3_parent {
 		//cout << x2 << "vec3_parent::norm" << endl;
 	}
 };
+struct vec4 {
+	string name{ "hello" };
+};
+struct vec3_Meta;
 struct vec3 : public vec3_parent {
+	using MyMeta = vec3_Meta;
+	__cppast(Meta = { 0.f})
 	float x = 1;
+	__cppast(Meta = { 0.f})
 	float y = 2;
+	__cppast(Meta = { 0.f})
 	float z = 3;
 	string name{ "hellohellohellohellohellohello" };
+	__cppast(Meta = { {3,4} })
 	int norm(int x1, int& x2)override {
 		int tmp = x1 * 2 + 1;
 		x1 = x2;
@@ -36,29 +45,40 @@ struct vec3 : public vec3_parent {
 		x1 = x1 * 10;
 		cout << x1 << "::norm3" << endl;
 	}
-	using MyUClass = UClass_Meta<vec3, vec3_parent>;
+};
+struct vec3_Static_Meta {
 	//这里好像不需要
 	consteval static auto __StaticFields() {
 		return std::make_tuple(&vec3::x, &vec3::y, &vec3::z, &vec3::norm, &vec3::norm1, &vec3::norm2);
 	};
 	consteval static auto __MakeStaticFields() {
 		return std::array{
-			MakeStaticField(&vec3::x, "x"),
+			StaticMemberField(&vec3::x, "x", {0.f,vec4{}}),
-			MakeStaticField(&vec3::y, "y"),
+			StaticMemberField(&vec3::y, "y", {0.f,{}}),
-			MakeStaticField(&vec3::z, "z"),
+			StaticMemberField(&vec3::z, "z", {0.f,{}}),
-			MakeStaticField(&vec3::norm, "norm", { 10,9 }),
+			StaticMethodField(&vec3::norm, "norm",   {{10,9},{}}),
-			MakeStaticField(&vec3::norm1, "norm1", { 10 }),
+			StaticMethodField(&vec3::norm1, "norm1",  {{10},{}}),
-			MakeStaticField(&vec3::norm2, "norm2", { 10 }),
+			StaticMethodField(&vec3::norm2, "norm2",  {{10},{}}),
 		};
 	}
+	consteval static int Size() {
+		return fetch_meta_size<vec3_Static_Meta>();
+	}
+};
+constexpr int size = vec3_Static_Meta::Size();
+struct vec3_Meta : public Meta{
+	using MyStatic = vec3_Static_Meta;
+	using MyUClass = UClass_Meta<vec3, vec3_parent>;
+	inline static char s_data[MyStatic::Size()]{};
 	static auto __MakeFields() {
+		char* memory = &s_data[0];
 		return std::array{
-			Field<vec3>::MakeField(&vec3::x, "x"),
+			MemberField(&vec3::x, "x",memory, {0.f,vec4{}}),
-			Field<vec3>::MakeField(&vec3::y, "y"),
+			MemberField(&vec3::y, "y",memory, {0.f,{}}),
-			Field<vec3>::MakeField(&vec3::z, "z"),
+			MemberField(&vec3::z, "z",memory, {0.f,{}}),
-			Field<vec3>::MakeField(&vec3::norm, "norm", {10,9}),
+			MethodField(&vec3::norm,  "norm", memory, {{10,9},{}}),
-			Field<vec3>::MakeField(&vec3::norm1, "norm1", {10}),
+			MethodField(&vec3::norm1, "norm1",memory, {{10},{}}),
-			Field<vec3>::MakeField(&vec3::norm2, "norm2", {10}),
+			MethodField(&vec3::norm2, "norm2",memory, {{10},{}}),
 		};
 	};
 };

engine/3rdparty/zlib/test/refl_01.cpp

@@ -2,31 +2,33 @@
 #include <benchmark/benchmark.h>
 auto cls = &TypeInfo<vec3>::StaticClass;
 vec3 v;
+constexpr int smeta = sizeof(vec3_Meta);
+constexpr int scls = sizeof(decltype(*cls));
 auto ov = cls->New((void*)&v);
 constexpr Name func("norm");
 void TestRefl1(benchmark::State& state) {
 	int x = 1, y = 2;
 	for (auto _ : state) {
-		std::array<ArgsView, 4> arr{&x, ov.ptr};
+		std::array<Any, 4> arr{&x, ov.ptr};
-		svector<ArgsView> svec(&arr.front(), arr.size(), 2);
+		svector<Any> svec(&arr.front(), arr.size(), 2);
 		ov.Invoke("norm", svec);
 	}
 }
 BENCHMARK(TestRefl1);
 void TestRefl2(benchmark::State& state) {
 	int x = 1, y = 2;
-	constexpr auto id = GetStaticFieldID<vec3>(func);
+	constexpr auto id = GetStaticFieldID<vec3_Meta>(func);
 	auto field = cls->GetField(id);
 	for (auto _ : state) {
-		std::array<ArgsView, 4> arr{&x, ov.ptr};
+		std::array<Any, 4> arr{&x, ov.ptr};
-		svector<ArgsView> svec(&arr.front(), arr.size(), 2);
+		svector<Any> svec(&arr.front(), arr.size(), 2);
 		field->Invoke(svec);
 	}
 }
 BENCHMARK(TestRefl2);
 void TestRefl3(benchmark::State& state) {
 	int x = 1, y = 2;
-	constexpr auto id = GetStaticFieldID<vec3>(func);
+	constexpr auto id = GetStaticFieldID<vec3_Meta>(func);
 	auto field = cls->GetField(id);
 	for (auto _ : state) {
 		field->Invoke({ &x,ov.ptr, x, y });