diff --git a/Assets/XLua/Gen/BF_DZSDKManagerWrap.cs b/Assets/XLua/Gen/BF_DZSDKManagerWrap.cs new file mode 100644 index 000000000..18b777fb1 --- /dev/null +++ b/Assets/XLua/Gen/BF_DZSDKManagerWrap.cs @@ -0,0 +1,286 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class BFDZSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DZSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CSGetNotchScreenInfo", _m_CSGetNotchScreenInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreen", _m_GetNotchScreen); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenInfo", _m_GetNotchScreenInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenType", _m_GetNotchScreenType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenEnable", _m_GetNotchScreenEnable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenWidth", _m_GetNotchScreenWidth); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenHeight", _m_GetNotchScreenHeight); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.DZSDKManager(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to BF.DZSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CSGetNotchScreenInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CSGetNotchScreenInfo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreen(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _content = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.GetNotchScreen( _content ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenInfo( ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenType( ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenEnable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenEnable( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenWidth(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenWidth( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenHeight( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NotchScreenInfoWrap.cs b/Assets/XLua/Gen/BF_NotchScreenInfoWrap.cs new file mode 100644 index 000000000..3af032a32 --- /dev/null +++ b/Assets/XLua/Gen/BF_NotchScreenInfoWrap.cs @@ -0,0 +1,238 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class BFNotchScreenInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NotchScreenInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "notchType", _g_get_notchType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "notchType", _s_set_notchType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.NotchScreenInfo(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to BF.NotchScreenInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_notchType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.notchType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.width); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.height); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_notchType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + BF.NotchType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.notchType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.width = LuaAPI.xlua_tointeger(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.height = LuaAPI.xlua_tointeger(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_SDKManagerWrap.cs b/Assets/XLua/Gen/BF_SDKManagerWrap.cs index 875ebd9e8..0eb8760c4 100644 --- a/Assets/XLua/Gen/BF_SDKManagerWrap.cs +++ b/Assets/XLua/Gen/BF_SDKManagerWrap.cs @@ -21,12 +21,16 @@ namespace XLua.CSObjectWrap { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); System.Type type = typeof(BF.SDKManager); - Utils.BeginObjectRegister(type, L, translator, 0, 4, 6, 0); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 7, 0); Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLanguage", _m_GetLanguage); Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTimeZone", _m_GetTimeZone); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenType", _m_GetNotchScreenType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenEnable", _m_GetNotchScreenEnable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenWidth", _m_GetNotchScreenWidth); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenHeight", _m_GetNotchScreenHeight); Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFLoginSDKMgr", _g_get_BFLoginSDKMgr); @@ -35,6 +39,7 @@ namespace XLua.CSObjectWrap Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFIronSourceSDKMgr", _g_get_BFIronSourceSDKMgr); Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFNativeSDKMgr", _g_get_BFNativeSDKMgr); Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFThirdReportSDKMgr", _g_get_BFThirdReportSDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DZSDKMgr", _g_get_DZSDKMgr); @@ -201,6 +206,118 @@ namespace XLua.CSObjectWrap } + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenType( ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenEnable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenEnable( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenWidth(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenWidth( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotchScreenHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenHeight( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + @@ -288,6 +405,20 @@ namespace XLua.CSObjectWrap return 1; } + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DZSDKMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DZSDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + diff --git a/Assets/XLua/Gen/BaseBehaviourWrap.cs b/Assets/XLua/Gen/BaseBehaviourWrap.cs new file mode 100644 index 000000000..2dfff0c6a --- /dev/null +++ b/Assets/XLua/Gen/BaseBehaviourWrap.cs @@ -0,0 +1,82 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class BaseBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BaseBehaviour); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CachedTransform", _g_get_CachedTransform); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BaseBehaviour does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CachedTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BaseBehaviour gen_to_be_invoked = (BaseBehaviour)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CachedTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/CodeGeneratedSingletonWrap.cs b/Assets/XLua/Gen/CodeGeneratedSingletonWrap.cs new file mode 100644 index 000000000..5312bdd18 --- /dev/null +++ b/Assets/XLua/Gen/CodeGeneratedSingletonWrap.cs @@ -0,0 +1,67 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class CodeGeneratedSingletonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(CodeGeneratedSingleton); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "CodeGeneratedSingleton does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/EnumWrap.cs b/Assets/XLua/Gen/EnumWrap.cs index 7f909c92c..b4fa09ef9 100644 --- a/Assets/XLua/Gen/EnumWrap.cs +++ b/Assets/XLua/Gen/EnumWrap.cs @@ -74,6 +74,482 @@ namespace XLua.CSObjectWrap } } + public class ISAdQualityDeviceIdTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ISAdQualityDeviceIdType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ISAdQualityDeviceIdType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ISAdQualityDeviceIdType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NONE", ISAdQualityDeviceIdType.NONE); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GAID", ISAdQualityDeviceIdType.GAID); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IDFA", ISAdQualityDeviceIdType.IDFA); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ISAdQualityDeviceIdType), L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CastFrom(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaTypes lua_type = LuaAPI.lua_type(L, 1); + if (lua_type == LuaTypes.LUA_TNUMBER) + { + translator.PushISAdQualityDeviceIdType(L, (ISAdQualityDeviceIdType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "NONE")) + { + translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.NONE); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "GAID")) + { + translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.GAID); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "IDFA")) + { + translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.IDFA); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ISAdQualityDeviceIdType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityDeviceIdType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ISAdQualityAdTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ISAdQualityAdType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ISAdQualityAdType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ISAdQualityAdType), L, null, 14, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNKNOWN", ISAdQualityAdType.UNKNOWN); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RICH_MEDIA", ISAdQualityAdType.RICH_MEDIA); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INTERSTITIAL", ISAdQualityAdType.INTERSTITIAL); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "APP_WALL", ISAdQualityAdType.APP_WALL); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIDEO", ISAdQualityAdType.VIDEO); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REWARDED_VIDEO", ISAdQualityAdType.REWARDED_VIDEO); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NATIVE", ISAdQualityAdType.NATIVE); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BANNER", ISAdQualityAdType.BANNER); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OFFER_WALL", ISAdQualityAdType.OFFER_WALL); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NATIVE_HTML", ISAdQualityAdType.NATIVE_HTML); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EXTERNAL", ISAdQualityAdType.EXTERNAL); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REWARDED", ISAdQualityAdType.REWARDED); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INTERACTIVE", ISAdQualityAdType.INTERACTIVE); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ISAdQualityAdType), L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CastFrom(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaTypes lua_type = LuaAPI.lua_type(L, 1); + if (lua_type == LuaTypes.LUA_TNUMBER) + { + translator.PushISAdQualityAdType(L, (ISAdQualityAdType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "UNKNOWN")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.UNKNOWN); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "RICH_MEDIA")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.RICH_MEDIA); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "INTERSTITIAL")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.INTERSTITIAL); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "APP_WALL")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.APP_WALL); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "VIDEO")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.VIDEO); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "REWARDED_VIDEO")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.REWARDED_VIDEO); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NATIVE")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.NATIVE); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "BANNER")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.BANNER); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OFFER_WALL")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.OFFER_WALL); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NATIVE_HTML")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.NATIVE_HTML); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EXTERNAL")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.EXTERNAL); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "REWARDED")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.REWARDED); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "INTERACTIVE")) + { + translator.PushISAdQualityAdType(L, ISAdQualityAdType.INTERACTIVE); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ISAdQualityAdType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityAdType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ISAdQualityInitErrorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ISAdQualityInitError), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ISAdQualityInitError), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ISAdQualityInitError), L, null, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_QUALITY_SDK_WAS_SHUTDOWN", ISAdQualityInitError.AD_QUALITY_SDK_WAS_SHUTDOWN); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ILLEGAL_USER_ID", ISAdQualityInitError.ILLEGAL_USER_ID); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ILLEGAL_APP_KEY", ISAdQualityInitError.ILLEGAL_APP_KEY); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EXCEPTION_ON_INIT", ISAdQualityInitError.EXCEPTION_ON_INIT); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NO_NETWORK_CONNECTION", ISAdQualityInitError.NO_NETWORK_CONNECTION); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONFIG_LOAD_TIMEOUT", ISAdQualityInitError.CONFIG_LOAD_TIMEOUT); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONNECTOR_LOAD_TIMEOUT", ISAdQualityInitError.CONNECTOR_LOAD_TIMEOUT); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_NETWORK_VERSION_NOT_SUPPORTED_YET", ISAdQualityInitError.AD_NETWORK_VERSION_NOT_SUPPORTED_YET); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK", ISAdQualityInitError.AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_QUALITY_ALREADY_INITIALIZED", ISAdQualityInitError.AD_QUALITY_ALREADY_INITIALIZED); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ISAdQualityInitError), L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CastFrom(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaTypes lua_type = LuaAPI.lua_type(L, 1); + if (lua_type == LuaTypes.LUA_TNUMBER) + { + translator.PushISAdQualityInitError(L, (ISAdQualityInitError)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "AD_QUALITY_SDK_WAS_SHUTDOWN")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_QUALITY_SDK_WAS_SHUTDOWN); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ILLEGAL_USER_ID")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.ILLEGAL_USER_ID); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ILLEGAL_APP_KEY")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.ILLEGAL_APP_KEY); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EXCEPTION_ON_INIT")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.EXCEPTION_ON_INIT); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NO_NETWORK_CONNECTION")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.NO_NETWORK_CONNECTION); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CONFIG_LOAD_TIMEOUT")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.CONFIG_LOAD_TIMEOUT); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CONNECTOR_LOAD_TIMEOUT")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.CONNECTOR_LOAD_TIMEOUT); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_NETWORK_VERSION_NOT_SUPPORTED_YET")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_NETWORK_VERSION_NOT_SUPPORTED_YET); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_QUALITY_ALREADY_INITIALIZED")) + { + translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_QUALITY_ALREADY_INITIALIZED); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ISAdQualityInitError!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityInitError! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ISAdQualityLogLevelWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ISAdQualityLogLevel), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ISAdQualityLogLevel), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ISAdQualityLogLevel), L, null, 7, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NONE", ISAdQualityLogLevel.NONE); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ERROR", ISAdQualityLogLevel.ERROR); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WARNING", ISAdQualityLogLevel.WARNING); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INFO", ISAdQualityLogLevel.INFO); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEBUG", ISAdQualityLogLevel.DEBUG); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VERBOSE", ISAdQualityLogLevel.VERBOSE); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ISAdQualityLogLevel), L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CastFrom(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaTypes lua_type = LuaAPI.lua_type(L, 1); + if (lua_type == LuaTypes.LUA_TNUMBER) + { + translator.PushISAdQualityLogLevel(L, (ISAdQualityLogLevel)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "NONE")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.NONE); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ERROR")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.ERROR); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WARNING")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.WARNING); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "INFO")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.INFO); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DEBUG")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.DEBUG); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "VERBOSE")) + { + translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.VERBOSE); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ISAdQualityLogLevel!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityLogLevel! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ISAdQualityMediationNetworkWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ISAdQualityMediationNetwork), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ISAdQualityMediationNetwork), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ISAdQualityMediationNetwork), L, null, 10, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNKNOWN", ISAdQualityMediationNetwork.UNKNOWN); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB", ISAdQualityMediationNetwork.ADMOB); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DT_FAIR_BID", ISAdQualityMediationNetwork.DT_FAIR_BID); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HELIUM", ISAdQualityMediationNetwork.HELIUM); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LEVEL_PLAY", ISAdQualityMediationNetwork.LEVEL_PLAY); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAX", ISAdQualityMediationNetwork.MAX); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNITY", ISAdQualityMediationNetwork.UNITY); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SELF_MEDIATED", ISAdQualityMediationNetwork.SELF_MEDIATED); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OTHER", ISAdQualityMediationNetwork.OTHER); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ISAdQualityMediationNetwork), L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CastFrom(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaTypes lua_type = LuaAPI.lua_type(L, 1); + if (lua_type == LuaTypes.LUA_TNUMBER) + { + translator.PushISAdQualityMediationNetwork(L, (ISAdQualityMediationNetwork)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "UNKNOWN")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.UNKNOWN); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ADMOB")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.ADMOB); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DT_FAIR_BID")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.DT_FAIR_BID); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "HELIUM")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.HELIUM); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LEVEL_PLAY")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.LEVEL_PLAY); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MAX")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.MAX); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UNITY")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.UNITY); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "SELF_MEDIATED")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.SELF_MEDIATED); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OTHER")) + { + translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.OTHER); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ISAdQualityMediationNetwork!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityMediationNetwork! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + public class UIImageSheetAnimationAnimationTypeWrap { public static void __Register(RealStatePtr L) diff --git a/Assets/XLua/Gen/ISAdQualityConfigWrap.cs b/Assets/XLua/Gen/ISAdQualityConfigWrap.cs new file mode 100644 index 000000000..f2c6a17e5 --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualityConfigWrap.cs @@ -0,0 +1,303 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualityConfigWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualityConfig); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserId", _g_get_UserId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TestMode", _g_get_TestMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LogLevel", _g_get_LogLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdQualityInitCallback", _g_get_AdQualityInitCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InitializationSource", _g_get_InitializationSource); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Coppa", _g_get_Coppa); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeviceIdType", _g_get_DeviceIdType); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UserId", _s_set_UserId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TestMode", _s_set_TestMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "LogLevel", _s_set_LogLevel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdQualityInitCallback", _s_set_AdQualityInitCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InitializationSource", _s_set_InitializationSource); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Coppa", _s_set_Coppa); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DeviceIdType", _s_set_DeviceIdType); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ISAdQualityConfig(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityConfig constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.UserId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TestMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.TestMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LogLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + translator.PushISAdQualityLogLevel(L, gen_to_be_invoked.LogLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdQualityInitCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.AdQualityInitCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InitializationSource(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.InitializationSource); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Coppa(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Coppa); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeviceIdType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + translator.PushISAdQualityDeviceIdType(L, gen_to_be_invoked.DeviceIdType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UserId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UserId = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TestMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TestMode = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LogLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + ISAdQualityLogLevel gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.LogLevel = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AdQualityInitCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdQualityInitCallback = (ISAdQualityInitCallback)translator.GetObject(L, 2, typeof(ISAdQualityInitCallback)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_InitializationSource(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InitializationSource = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Coppa(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Coppa = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DeviceIdType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1); + ISAdQualityDeviceIdType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.DeviceIdType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ISAdQualityCustomMediationRevenueWrap.cs b/Assets/XLua/Gen/ISAdQualityCustomMediationRevenueWrap.cs new file mode 100644 index 000000000..c82c271f8 --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualityCustomMediationRevenueWrap.cs @@ -0,0 +1,210 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualityCustomMediationRevenueWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualityCustomMediationRevenue); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MediationNetwork", _g_get_MediationNetwork); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdType", _g_get_AdType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Revenue", _g_get_Revenue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Placement", _g_get_Placement); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MediationNetwork", _s_set_MediationNetwork); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdType", _s_set_AdType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Revenue", _s_set_Revenue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Placement", _s_set_Placement); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ISAdQualityCustomMediationRevenue(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityCustomMediationRevenue constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MediationNetwork(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + translator.PushISAdQualityMediationNetwork(L, gen_to_be_invoked.MediationNetwork); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + translator.PushISAdQualityAdType(L, gen_to_be_invoked.AdType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Revenue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Revenue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Placement(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Placement); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MediationNetwork(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + ISAdQualityMediationNetwork gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.MediationNetwork = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AdType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + ISAdQualityAdType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.AdType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Revenue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Revenue = LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Placement(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Placement = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/AFAdRevenueEventWrap.cs b/Assets/XLua/Gen/ISAdQualityEditorScriptWrap.cs similarity index 63% rename from Assets/XLua/Gen/AFAdRevenueEventWrap.cs rename to Assets/XLua/Gen/ISAdQualityEditorScriptWrap.cs index 71113b243..7c5c1d28a 100644 --- a/Assets/XLua/Gen/AFAdRevenueEventWrap.cs +++ b/Assets/XLua/Gen/ISAdQualityEditorScriptWrap.cs @@ -15,12 +15,12 @@ using System.Collections.Generic; namespace XLua.CSObjectWrap { using Utils = XLua.Utils; - public class AFAdRevenueEventWrap + public class ISAdQualityEditorScriptWrap { public static void __Register(RealStatePtr L) { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); - System.Type type = typeof(AFAdRevenueEvent); + System.Type type = typeof(ISAdQualityEditorScript); Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); @@ -31,14 +31,9 @@ namespace XLua.CSObjectWrap Utils.EndObjectRegister(type, L, translator, null, null, null, null, null); - Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUNTRY", AFAdRevenueEvent.COUNTRY); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_UNIT", AFAdRevenueEvent.AD_UNIT); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_TYPE", AFAdRevenueEvent.AD_TYPE); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLACEMENT", AFAdRevenueEvent.PLACEMENT); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ECPM_PAYLOAD", AFAdRevenueEvent.ECPM_PAYLOAD); @@ -55,7 +50,7 @@ namespace XLua.CSObjectWrap if(LuaAPI.lua_gettop(L) == 1) { - var gen_ret = new AFAdRevenueEvent(); + var gen_ret = new ISAdQualityEditorScript(); translator.Push(L, gen_ret); return 1; @@ -65,7 +60,7 @@ namespace XLua.CSObjectWrap catch(System.Exception gen_e) { return LuaAPI.luaL_error(L, "c# exception:" + gen_e); } - return LuaAPI.luaL_error(L, "invalid arguments to AFAdRevenueEvent constructor!"); + return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityEditorScript constructor!"); } diff --git a/Assets/XLua/Gen/ISAdQualityInitCallbackWrap.cs b/Assets/XLua/Gen/ISAdQualityInitCallbackWrap.cs new file mode 100644 index 000000000..c82a70644 --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualityInitCallbackWrap.cs @@ -0,0 +1,125 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualityInitCallbackWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualityInitCallback); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "adQualitySdkInitSuccess", _m_adQualitySdkInitSuccess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "adQualitySdkInitFailed", _m_adQualitySdkInitFailed); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "ISAdQualityInitCallback does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_adQualitySdkInitSuccess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ISAdQualityInitCallback gen_to_be_invoked = (ISAdQualityInitCallback)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.adQualitySdkInitSuccess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_adQualitySdkInitFailed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ISAdQualityInitCallback gen_to_be_invoked = (ISAdQualityInitCallback)translator.FastGetCSObj(L, 1); + + + + { + ISAdQualityInitError _adQualityInitError;translator.Get(L, 2, out _adQualityInitError); + string _errorMessage = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.adQualitySdkInitFailed( _adQualityInitError, _errorMessage ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ISAdQualityInitCallbackWrapperWrap.cs b/Assets/XLua/Gen/ISAdQualityInitCallbackWrapperWrap.cs new file mode 100644 index 000000000..b7742eeba --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualityInitCallbackWrapperWrap.cs @@ -0,0 +1,115 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualityInitCallbackWrapperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualityInitCallbackWrapper); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdQualityInitCallback", _g_get_AdQualityInitCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdQualityInitCallback", _s_set_AdQualityInitCallback); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ISAdQualityInitCallbackWrapper(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityInitCallbackWrapper constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdQualityInitCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityInitCallbackWrapper gen_to_be_invoked = (ISAdQualityInitCallbackWrapper)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.AdQualityInitCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AdQualityInitCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualityInitCallbackWrapper gen_to_be_invoked = (ISAdQualityInitCallbackWrapper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdQualityInitCallback = (ISAdQualityInitCallback)translator.GetObject(L, 2, typeof(ISAdQualityInitCallback)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ISAdQualityJSON_JsonWrap.cs b/Assets/XLua/Gen/ISAdQualityJSON_JsonWrap.cs new file mode 100644 index 000000000..f73941b18 --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualityJSON_JsonWrap.cs @@ -0,0 +1,123 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualityJSONJsonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualityJSON.Json); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Deserialize", _m_Deserialize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Serialize", _m_Serialize_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "ISAdQualityJSON.Json does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Deserialize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _json = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ISAdQualityJSON.Json.Deserialize( _json ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Serialize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ISAdQualityJSON.Json.Serialize( _obj ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ISAdQualitySegmentWrap.cs b/Assets/XLua/Gen/ISAdQualitySegmentWrap.cs new file mode 100644 index 000000000..55c728794 --- /dev/null +++ b/Assets/XLua/Gen/ISAdQualitySegmentWrap.cs @@ -0,0 +1,391 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ISAdQualitySegmentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ISAdQualitySegment); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setCustom", _m_setCustom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getSegmentAsDict", _m_getSegmentAsDict); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "age", _g_get_age); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gender", _g_get_gender); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "level", _g_get_level); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPaying", _g_get_isPaying); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inAppPurchasesTotal", _g_get_inAppPurchasesTotal); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "userCreationDate", _g_get_userCreationDate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customs", _g_get_customs); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "name", _s_set_name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "age", _s_set_age); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gender", _s_set_gender); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "level", _s_set_level); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isPaying", _s_set_isPaying); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inAppPurchasesTotal", _s_set_inAppPurchasesTotal); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "userCreationDate", _s_set_userCreationDate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "customs", _s_set_customs); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ISAdQualitySegment(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualitySegment constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setCustom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setCustom( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getSegmentAsDict(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getSegmentAsDict( ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.name); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.age); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.gender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_level(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.level); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.isPaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inAppPurchasesTotal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.inAppPurchasesTotal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_userCreationDate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.userCreationDate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.customs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.name = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.age = LuaAPI.xlua_tointeger(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.gender = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_level(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.level = LuaAPI.xlua_tointeger(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isPaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isPaying = LuaAPI.xlua_tointeger(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inAppPurchasesTotal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.inAppPurchasesTotal = LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_userCreationDate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.userCreationDate = LuaAPI.lua_toint64(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_customs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.customs = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/AppsFlyerSDK_AppsFlyerAdRevenueWrap.cs b/Assets/XLua/Gen/ISAdQualityUtilsWrap.cs similarity index 55% rename from Assets/XLua/Gen/AppsFlyerSDK_AppsFlyerAdRevenueWrap.cs rename to Assets/XLua/Gen/ISAdQualityUtilsWrap.cs index b193b997c..df54b7cad 100644 --- a/Assets/XLua/Gen/AppsFlyerSDK_AppsFlyerAdRevenueWrap.cs +++ b/Assets/XLua/Gen/ISAdQualityUtilsWrap.cs @@ -15,12 +15,12 @@ using System.Collections.Generic; namespace XLua.CSObjectWrap { using Utils = XLua.Utils; - public class AppsFlyerSDKAppsFlyerAdRevenueWrap + public class ISAdQualityUtilsWrap { public static void __Register(RealStatePtr L) { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); - System.Type type = typeof(AppsFlyerSDK.AppsFlyerAdRevenue); + System.Type type = typeof(ISAdQualityUtils); Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); @@ -32,12 +32,12 @@ namespace XLua.CSObjectWrap null, null, null); Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0); - Utils.RegisterFunc(L, Utils.CLS_IDX, "start", _m_start_xlua_st_); - Utils.RegisterFunc(L, Utils.CLS_IDX, "setIsDebug", _m_setIsDebug_xlua_st_); - Utils.RegisterFunc(L, Utils.CLS_IDX, "logAdRevenue", _m_logAdRevenue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogDebug", _m_LogDebug_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogError", _m_LogError_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarning", _m_LogWarning_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetClassName", _m_GetClassName_xlua_st_); - Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kAppsFlyerAdRevenueVersion", AppsFlyerSDK.AppsFlyerAdRevenue.kAppsFlyerAdRevenueVersion); @@ -48,24 +48,7 @@ namespace XLua.CSObjectWrap [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] static int __CreateInstance(RealStatePtr L) { - - try { - ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); - if(LuaAPI.lua_gettop(L) == 1) - { - - var gen_ret = new AppsFlyerSDK.AppsFlyerAdRevenue(); - translator.Push(L, gen_ret); - - return 1; - } - - } - catch(System.Exception gen_e) { - return LuaAPI.luaL_error(L, "c# exception:" + gen_e); - } - return LuaAPI.luaL_error(L, "invalid arguments to AppsFlyerSDK.AppsFlyerAdRevenue constructor!"); - + return LuaAPI.luaL_error(L, "ISAdQualityUtils does not have a constructor!"); } @@ -76,7 +59,7 @@ namespace XLua.CSObjectWrap [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] - static int _m_start_xlua_st_(RealStatePtr L) + static int _m_LogDebug_xlua_st_(RealStatePtr L) { try { @@ -84,8 +67,10 @@ namespace XLua.CSObjectWrap { + string _tag = LuaAPI.lua_tostring(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); - AppsFlyerSDK.AppsFlyerAdRevenue.start( ); + ISAdQualityUtils.LogDebug( _tag, _message ); @@ -99,7 +84,7 @@ namespace XLua.CSObjectWrap } [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] - static int _m_setIsDebug_xlua_st_(RealStatePtr L) + static int _m_LogError_xlua_st_(RealStatePtr L) { try { @@ -107,9 +92,10 @@ namespace XLua.CSObjectWrap { - bool _isDebug = LuaAPI.lua_toboolean(L, 1); + string _tag = LuaAPI.lua_tostring(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); - AppsFlyerSDK.AppsFlyerAdRevenue.setIsDebug( _isDebug ); + ISAdQualityUtils.LogError( _tag, _message ); @@ -123,7 +109,32 @@ namespace XLua.CSObjectWrap } [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] - static int _m_logAdRevenue_xlua_st_(RealStatePtr L) + static int _m_LogWarning_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _tag = LuaAPI.lua_tostring(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); + + ISAdQualityUtils.LogWarning( _tag, _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetClassName_xlua_st_(RealStatePtr L) { try { @@ -133,17 +144,14 @@ namespace XLua.CSObjectWrap { - string _monetizationNetwork = LuaAPI.lua_tostring(L, 1); - AppsFlyerSDK.AppsFlyerAdRevenueMediationNetworkType _mediationNetwork;translator.Get(L, 2, out _mediationNetwork); - double _eventRevenue = LuaAPI.lua_tonumber(L, 3); - string _revenueCurrency = LuaAPI.lua_tostring(L, 4); - System.Collections.Generic.Dictionary _additionalParameters = (System.Collections.Generic.Dictionary)translator.GetObject(L, 5, typeof(System.Collections.Generic.Dictionary)); + object _target = translator.GetObject(L, 1, typeof(object)); - AppsFlyerSDK.AppsFlyerAdRevenue.logAdRevenue( _monetizationNetwork, _mediationNetwork, _eventRevenue, _revenueCurrency, _additionalParameters ); + var gen_ret = ISAdQualityUtils.GetClassName( _target ); + LuaAPI.lua_pushstring(L, gen_ret); - return 0; + return 1; } } catch(System.Exception gen_e) { diff --git a/Assets/XLua/Gen/IronSourceAdQualityManifestToolsWrap.cs b/Assets/XLua/Gen/IronSourceAdQualityManifestToolsWrap.cs new file mode 100644 index 000000000..3c20c97eb --- /dev/null +++ b/Assets/XLua/Gen/IronSourceAdQualityManifestToolsWrap.cs @@ -0,0 +1,554 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class IronSourceAdQualityManifestToolsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceAdQualityManifestTools); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 18, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GenerateManifest", _m_GenerateManifest_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateManifest", _m_UpdateManifest_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddActivity", _m_AddActivity_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveActivity", _m_RemoveActivity_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPermission", _m_SetPermission_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemovePermission", _m_RemovePermission_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendApplicationElement", _m_AppendApplicationElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveApplicationElement", _m_RemoveApplicationElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PrependManifestElement", _m_PrependManifestElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveManifestElement", _m_RemoveManifestElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddMetaDataTag", _m_AddMetaDataTag_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendElementIfMissing", _m_AppendElementIfMissing_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PrependElementIfMissing", _m_PrependElementIfMissing_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveElement", _m_RemoveElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindChildNode", _m_FindChildNode_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindChildElement", _m_FindChildElement_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindElementWithTagAndName", _m_FindElementWithTagAndName_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new IronSourceAdQualityManifestTools(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQualityManifestTools constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GenerateManifest_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + IronSourceAdQualityManifestTools.GenerateManifest( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateManifest_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + IronSourceAdQualityManifestTools.UpdateManifest( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddActivity_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _activityName = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.Dictionary _attributes = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + IronSourceAdQualityManifestTools.AddActivity( _activityName, _attributes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveActivity_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _activityName = LuaAPI.lua_tostring(L, 1); + + IronSourceAdQualityManifestTools.RemoveActivity( _activityName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPermission_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _permissionName = LuaAPI.lua_tostring(L, 1); + + IronSourceAdQualityManifestTools.SetPermission( _permissionName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemovePermission_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _permissionName = LuaAPI.lua_tostring(L, 1); + + IronSourceAdQualityManifestTools.RemovePermission( _permissionName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendApplicationElement_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _attributes = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = IronSourceAdQualityManifestTools.AppendApplicationElement( _tagName, _name, _attributes ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveApplicationElement_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + + IronSourceAdQualityManifestTools.RemoveApplicationElement( _tagName, _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PrependManifestElement_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = IronSourceAdQualityManifestTools.PrependManifestElement( _tagName, _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveManifestElement_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + + IronSourceAdQualityManifestTools.RemoveManifestElement( _tagName, _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMetaDataTag_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _mdName = LuaAPI.lua_tostring(L, 1); + string _mdValue = LuaAPI.lua_tostring(L, 2); + + var gen_ret = IronSourceAdQualityManifestTools.AddMetaDataTag( _mdName, _mdValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendElementIfMissing_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _otherAttributes = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 4, typeof(System.Xml.XmlNode)); + + var gen_ret = IronSourceAdQualityManifestTools.AppendElementIfMissing( _tagName, _name, _otherAttributes, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PrependElementIfMissing_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _otherAttributes = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 4, typeof(System.Xml.XmlNode)); + + var gen_ret = IronSourceAdQualityManifestTools.PrependElementIfMissing( _tagName, _name, _otherAttributes, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveElement_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 3, typeof(System.Xml.XmlNode)); + + IronSourceAdQualityManifestTools.RemoveElement( _tagName, _name, _parent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindChildNode_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 1, typeof(System.Xml.XmlNode)); + string _tagName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = IronSourceAdQualityManifestTools.FindChildNode( _parent, _tagName ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindChildElement_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 1, typeof(System.Xml.XmlNode)); + string _tagName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = IronSourceAdQualityManifestTools.FindChildElement( _parent, _tagName ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindElementWithTagAndName_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tagName = LuaAPI.lua_tostring(L, 1); + string _name = LuaAPI.lua_tostring(L, 2); + System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 3, typeof(System.Xml.XmlNode)); + + var gen_ret = IronSourceAdQualityManifestTools.FindElementWithTagAndName( _tagName, _name, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceAdQualityWrap.cs b/Assets/XLua/Gen/IronSourceAdQualityWrap.cs new file mode 100644 index 000000000..e0cb4c4eb --- /dev/null +++ b/Assets/XLua/Gen/IronSourceAdQualityWrap.cs @@ -0,0 +1,205 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class IronSourceAdQualityWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceAdQuality); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Initialize", _m_Initialize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeUserId", _m_ChangeUserId_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SendCustomMediationRevenue", _m_SendCustomMediationRevenue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setSegment", _m_setSegment_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new IronSourceAdQuality(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQuality constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _appKey = LuaAPI.lua_tostring(L, 1); + + IronSourceAdQuality.Initialize( _appKey ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _appKey = LuaAPI.lua_tostring(L, 1); + ISAdQualityConfig _adQualityConfig = (ISAdQualityConfig)translator.GetObject(L, 2, typeof(ISAdQualityConfig)); + + IronSourceAdQuality.Initialize( _appKey, _adQualityConfig ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQuality.Initialize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeUserId_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _userId = LuaAPI.lua_tostring(L, 1); + + IronSourceAdQuality.ChangeUserId( _userId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendCustomMediationRevenue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + ISAdQualityCustomMediationRevenue _customMediationRevenue = (ISAdQualityCustomMediationRevenue)translator.GetObject(L, 1, typeof(ISAdQualityCustomMediationRevenue)); + + IronSourceAdQuality.SendCustomMediationRevenue( _customMediationRevenue ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setSegment_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + ISAdQualitySegment _segment = (ISAdQualitySegment)translator.GetObject(L, 1, typeof(ISAdQualitySegment)); + + IronSourceAdQuality.setSegment( _segment ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/MolocoSdk_MolocoSDKWrap.cs b/Assets/XLua/Gen/MolocoSdk_MolocoSDKWrap.cs new file mode 100644 index 000000000..0b01d45fa --- /dev/null +++ b/Assets/XLua/Gen/MolocoSdk_MolocoSDKWrap.cs @@ -0,0 +1,94 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class MolocoSdkMolocoSDKWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(MolocoSdk.MolocoSDK); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPrivacy", _m_SetPrivacy_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "MolocoSdk.MolocoSDK does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPrivacy_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + MolocoSdk.PrivacySettings _privacySettings = (MolocoSdk.PrivacySettings)translator.GetObject(L, 1, typeof(MolocoSdk.PrivacySettings)); + + MolocoSdk.MolocoSDK.SetPrivacy( _privacySettings ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/MolocoSdk_PrivacySettingsWrap.cs b/Assets/XLua/Gen/MolocoSdk_PrivacySettingsWrap.cs new file mode 100644 index 000000000..66deebec2 --- /dev/null +++ b/Assets/XLua/Gen/MolocoSdk_PrivacySettingsWrap.cs @@ -0,0 +1,180 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class MolocoSdkPrivacySettingsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(MolocoSdk.PrivacySettings); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsUserConsent", _g_get_IsUserConsent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsAgeRestrictedUser", _g_get_IsAgeRestrictedUser); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsDoNotSell", _g_get_IsDoNotSell); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsUserConsent", _s_set_IsUserConsent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsAgeRestrictedUser", _s_set_IsAgeRestrictedUser); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsDoNotSell", _s_set_IsDoNotSell); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new MolocoSdk.PrivacySettings(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to MolocoSdk.PrivacySettings constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsUserConsent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.IsUserConsent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsAgeRestrictedUser(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.IsAgeRestrictedUser); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsDoNotSell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.IsDoNotSell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsUserConsent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + System.Nullable gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.IsUserConsent = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsAgeRestrictedUser(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + System.Nullable gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.IsAgeRestrictedUser = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsDoNotSell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1); + System.Nullable gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.IsDoNotSell = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ObjectDictionaryWrap.cs b/Assets/XLua/Gen/ObjectDictionaryWrap.cs new file mode 100644 index 000000000..f744001b8 --- /dev/null +++ b/Assets/XLua/Gen/ObjectDictionaryWrap.cs @@ -0,0 +1,175 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ObjectDictionaryWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ObjectDictionary); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConvertUkvp", _m_ConvertUkvp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConvertOkvp", _m_ConvertOkvp); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "values", _g_get_values); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "values", _s_set_values); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ObjectDictionary(); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ObjectDictionary constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertUkvp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1); + + + + { + UnityKeyValuePair _ukvp = (UnityKeyValuePair)translator.GetObject(L, 2, typeof(UnityKeyValuePair)); + + var gen_ret = gen_to_be_invoked.ConvertUkvp( _ukvp ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertOkvp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1); + + + + { + ObjectKvp _okvp = (ObjectKvp)translator.GetObject(L, 2, typeof(ObjectKvp)); + + var gen_ret = gen_to_be_invoked.ConvertOkvp( _okvp ); + translator.Push(L, gen_ret); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_values(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.values); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_values(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ObjectKvpWrap.cs b/Assets/XLua/Gen/ObjectKvpWrap.cs new file mode 100644 index 000000000..c9f457777 --- /dev/null +++ b/Assets/XLua/Gen/ObjectKvpWrap.cs @@ -0,0 +1,148 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class ObjectKvpWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ObjectKvp); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Value", _g_get_Value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Value", _s_set_Value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + var gen_ret = new ObjectKvp(_key, _value); + translator.Push(L, gen_ret); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ObjectKvp constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Value); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.value); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Value = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = LuaAPI.lua_tostring(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/SceneSingletonWrap.cs b/Assets/XLua/Gen/SceneSingletonWrap.cs new file mode 100644 index 000000000..615bb03f6 --- /dev/null +++ b/Assets/XLua/Gen/SceneSingletonWrap.cs @@ -0,0 +1,67 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class SceneSingletonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(SceneSingleton); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "SceneSingleton does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnitySingletonWrap.cs b/Assets/XLua/Gen/UnitySingletonWrap.cs new file mode 100644 index 000000000..e87e181f9 --- /dev/null +++ b/Assets/XLua/Gen/UnitySingletonWrap.cs @@ -0,0 +1,67 @@ +#if USE_UNI_LUA +using LuaAPI = UniLua.Lua; +using RealStatePtr = UniLua.ILuaState; +using LuaCSFunction = UniLua.CSharpFunctionDelegate; +#else +using LuaAPI = XLua.LuaDLL.Lua; +using RealStatePtr = System.IntPtr; +using LuaCSFunction = XLua.LuaDLL.lua_CSFunction; +#endif + +using XLua; +using System.Collections.Generic; + + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnitySingletonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnitySingleton); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnitySingleton does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/WrapPusher.cs b/Assets/XLua/Gen/WrapPusher.cs index bb5ec3755..f1eb10947 100644 --- a/Assets/XLua/Gen/WrapPusher.cs +++ b/Assets/XLua/Gen/WrapPusher.cs @@ -35,6 +35,11 @@ namespace XLua translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineBounds, translator.Get, translator.UpdateUnityEngineBounds); translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRay2D, translator.Get, translator.UpdateUnityEngineRay2D); translator.RegisterPushAndGetAndUpdate(translator.PushIronSourceBannerPosition, translator.Get, translator.UpdateIronSourceBannerPosition); + translator.RegisterPushAndGetAndUpdate(translator.PushISAdQualityDeviceIdType, translator.Get, translator.UpdateISAdQualityDeviceIdType); + translator.RegisterPushAndGetAndUpdate(translator.PushISAdQualityAdType, translator.Get, translator.UpdateISAdQualityAdType); + translator.RegisterPushAndGetAndUpdate(translator.PushISAdQualityInitError, translator.Get, translator.UpdateISAdQualityInitError); + translator.RegisterPushAndGetAndUpdate(translator.PushISAdQualityLogLevel, translator.Get, translator.UpdateISAdQualityLogLevel); + translator.RegisterPushAndGetAndUpdate(translator.PushISAdQualityMediationNetwork, translator.Get, translator.UpdateISAdQualityMediationNetwork); translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationAnimationType, translator.Get, translator.UpdateUIImageSheetAnimationAnimationType); translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationTimeType, translator.Get, translator.UpdateUIImageSheetAnimationTimeType); translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationStartFrameType, translator.Get, translator.UpdateUIImageSheetAnimationStartFrameType); @@ -732,6 +737,426 @@ namespace XLua } } + int ISAdQualityDeviceIdType_TypeID = -1; + int ISAdQualityDeviceIdType_EnumRef = -1; + + public void PushISAdQualityDeviceIdType(RealStatePtr L, ISAdQualityDeviceIdType val) + { + if (ISAdQualityDeviceIdType_TypeID == -1) + { + bool is_first; + ISAdQualityDeviceIdType_TypeID = getTypeId(L, typeof(ISAdQualityDeviceIdType), out is_first); + + if (ISAdQualityDeviceIdType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ISAdQualityDeviceIdType)); + ISAdQualityDeviceIdType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityDeviceIdType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityDeviceIdType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ISAdQualityDeviceIdType ,value="+val); + } + + LuaAPI.lua_getref(L, ISAdQualityDeviceIdType_EnumRef); + LuaAPI.lua_pushvalue(L, -2); + LuaAPI.xlua_rawseti(L, -2, (int)val); + LuaAPI.lua_pop(L, 1); + + } + + public void Get(RealStatePtr L, int index, out ISAdQualityDeviceIdType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityDeviceIdType_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityDeviceIdType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ISAdQualityDeviceIdType"); + } + val = (ISAdQualityDeviceIdType)e; + + } + else + { + val = (ISAdQualityDeviceIdType)objectCasters.GetCaster(typeof(ISAdQualityDeviceIdType))(L, index, null); + } + } + + public void UpdateISAdQualityDeviceIdType(RealStatePtr L, int index, ISAdQualityDeviceIdType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityDeviceIdType_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityDeviceIdType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ISAdQualityDeviceIdType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ISAdQualityAdType_TypeID = -1; + int ISAdQualityAdType_EnumRef = -1; + + public void PushISAdQualityAdType(RealStatePtr L, ISAdQualityAdType val) + { + if (ISAdQualityAdType_TypeID == -1) + { + bool is_first; + ISAdQualityAdType_TypeID = getTypeId(L, typeof(ISAdQualityAdType), out is_first); + + if (ISAdQualityAdType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ISAdQualityAdType)); + ISAdQualityAdType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityAdType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityAdType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ISAdQualityAdType ,value="+val); + } + + LuaAPI.lua_getref(L, ISAdQualityAdType_EnumRef); + LuaAPI.lua_pushvalue(L, -2); + LuaAPI.xlua_rawseti(L, -2, (int)val); + LuaAPI.lua_pop(L, 1); + + } + + public void Get(RealStatePtr L, int index, out ISAdQualityAdType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityAdType_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityAdType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ISAdQualityAdType"); + } + val = (ISAdQualityAdType)e; + + } + else + { + val = (ISAdQualityAdType)objectCasters.GetCaster(typeof(ISAdQualityAdType))(L, index, null); + } + } + + public void UpdateISAdQualityAdType(RealStatePtr L, int index, ISAdQualityAdType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityAdType_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityAdType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ISAdQualityAdType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ISAdQualityInitError_TypeID = -1; + int ISAdQualityInitError_EnumRef = -1; + + public void PushISAdQualityInitError(RealStatePtr L, ISAdQualityInitError val) + { + if (ISAdQualityInitError_TypeID == -1) + { + bool is_first; + ISAdQualityInitError_TypeID = getTypeId(L, typeof(ISAdQualityInitError), out is_first); + + if (ISAdQualityInitError_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ISAdQualityInitError)); + ISAdQualityInitError_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityInitError_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityInitError_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ISAdQualityInitError ,value="+val); + } + + LuaAPI.lua_getref(L, ISAdQualityInitError_EnumRef); + LuaAPI.lua_pushvalue(L, -2); + LuaAPI.xlua_rawseti(L, -2, (int)val); + LuaAPI.lua_pop(L, 1); + + } + + public void Get(RealStatePtr L, int index, out ISAdQualityInitError val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityInitError_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityInitError"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ISAdQualityInitError"); + } + val = (ISAdQualityInitError)e; + + } + else + { + val = (ISAdQualityInitError)objectCasters.GetCaster(typeof(ISAdQualityInitError))(L, index, null); + } + } + + public void UpdateISAdQualityInitError(RealStatePtr L, int index, ISAdQualityInitError val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityInitError_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityInitError"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ISAdQualityInitError ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ISAdQualityLogLevel_TypeID = -1; + int ISAdQualityLogLevel_EnumRef = -1; + + public void PushISAdQualityLogLevel(RealStatePtr L, ISAdQualityLogLevel val) + { + if (ISAdQualityLogLevel_TypeID == -1) + { + bool is_first; + ISAdQualityLogLevel_TypeID = getTypeId(L, typeof(ISAdQualityLogLevel), out is_first); + + if (ISAdQualityLogLevel_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ISAdQualityLogLevel)); + ISAdQualityLogLevel_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityLogLevel_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityLogLevel_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ISAdQualityLogLevel ,value="+val); + } + + LuaAPI.lua_getref(L, ISAdQualityLogLevel_EnumRef); + LuaAPI.lua_pushvalue(L, -2); + LuaAPI.xlua_rawseti(L, -2, (int)val); + LuaAPI.lua_pop(L, 1); + + } + + public void Get(RealStatePtr L, int index, out ISAdQualityLogLevel val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityLogLevel_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityLogLevel"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ISAdQualityLogLevel"); + } + val = (ISAdQualityLogLevel)e; + + } + else + { + val = (ISAdQualityLogLevel)objectCasters.GetCaster(typeof(ISAdQualityLogLevel))(L, index, null); + } + } + + public void UpdateISAdQualityLogLevel(RealStatePtr L, int index, ISAdQualityLogLevel val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityLogLevel_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityLogLevel"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ISAdQualityLogLevel ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ISAdQualityMediationNetwork_TypeID = -1; + int ISAdQualityMediationNetwork_EnumRef = -1; + + public void PushISAdQualityMediationNetwork(RealStatePtr L, ISAdQualityMediationNetwork val) + { + if (ISAdQualityMediationNetwork_TypeID == -1) + { + bool is_first; + ISAdQualityMediationNetwork_TypeID = getTypeId(L, typeof(ISAdQualityMediationNetwork), out is_first); + + if (ISAdQualityMediationNetwork_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ISAdQualityMediationNetwork)); + ISAdQualityMediationNetwork_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityMediationNetwork_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityMediationNetwork_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ISAdQualityMediationNetwork ,value="+val); + } + + LuaAPI.lua_getref(L, ISAdQualityMediationNetwork_EnumRef); + LuaAPI.lua_pushvalue(L, -2); + LuaAPI.xlua_rawseti(L, -2, (int)val); + LuaAPI.lua_pop(L, 1); + + } + + public void Get(RealStatePtr L, int index, out ISAdQualityMediationNetwork val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityMediationNetwork_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityMediationNetwork"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ISAdQualityMediationNetwork"); + } + val = (ISAdQualityMediationNetwork)e; + + } + else + { + val = (ISAdQualityMediationNetwork)objectCasters.GetCaster(typeof(ISAdQualityMediationNetwork))(L, index, null); + } + } + + public void UpdateISAdQualityMediationNetwork(RealStatePtr L, int index, ISAdQualityMediationNetwork val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityMediationNetwork_TypeID) + { + throw new Exception("invalid userdata for ISAdQualityMediationNetwork"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ISAdQualityMediationNetwork ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + int UIImageSheetAnimationAnimationType_TypeID = -1; int UIImageSheetAnimationAnimationType_EnumRef = -1; @@ -7265,6 +7690,36 @@ namespace XLua translator.PushIronSourceBannerPosition(L, array[index]); return true; } + else if (type == typeof(ISAdQualityDeviceIdType[])) + { + ISAdQualityDeviceIdType[] array = obj as ISAdQualityDeviceIdType[]; + translator.PushISAdQualityDeviceIdType(L, array[index]); + return true; + } + else if (type == typeof(ISAdQualityAdType[])) + { + ISAdQualityAdType[] array = obj as ISAdQualityAdType[]; + translator.PushISAdQualityAdType(L, array[index]); + return true; + } + else if (type == typeof(ISAdQualityInitError[])) + { + ISAdQualityInitError[] array = obj as ISAdQualityInitError[]; + translator.PushISAdQualityInitError(L, array[index]); + return true; + } + else if (type == typeof(ISAdQualityLogLevel[])) + { + ISAdQualityLogLevel[] array = obj as ISAdQualityLogLevel[]; + translator.PushISAdQualityLogLevel(L, array[index]); + return true; + } + else if (type == typeof(ISAdQualityMediationNetwork[])) + { + ISAdQualityMediationNetwork[] array = obj as ISAdQualityMediationNetwork[]; + translator.PushISAdQualityMediationNetwork(L, array[index]); + return true; + } else if (type == typeof(UIImageSheetAnimation.AnimationType[])) { UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[]; @@ -7787,6 +8242,36 @@ namespace XLua translator.Get(L, obj_idx, out array[array_idx]); return true; } + else if (type == typeof(ISAdQualityDeviceIdType[])) + { + ISAdQualityDeviceIdType[] array = obj as ISAdQualityDeviceIdType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ISAdQualityAdType[])) + { + ISAdQualityAdType[] array = obj as ISAdQualityAdType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ISAdQualityInitError[])) + { + ISAdQualityInitError[] array = obj as ISAdQualityInitError[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ISAdQualityLogLevel[])) + { + ISAdQualityLogLevel[] array = obj as ISAdQualityLogLevel[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ISAdQualityMediationNetwork[])) + { + ISAdQualityMediationNetwork[] array = obj as ISAdQualityMediationNetwork[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } else if (type == typeof(UIImageSheetAnimation.AnimationType[])) { UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[]; diff --git a/Assets/XLua/Gen/XLuaGenAutoRegister.cs b/Assets/XLua/Gen/XLuaGenAutoRegister.cs index 4c811c93d..79a8c89a1 100644 --- a/Assets/XLua/Gen/XLuaGenAutoRegister.cs +++ b/Assets/XLua/Gen/XLuaGenAutoRegister.cs @@ -1386,6 +1386,12 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(BF.BFThirdReportSDKManager), BFBFThirdReportSDKManagerWrap.__Register); + translator.DelayWrapLoader(typeof(BF.NotchScreenInfo), BFNotchScreenInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DZSDKManager), BFDZSDKManagerWrap.__Register); + + translator.DelayWrapLoader(typeof(BF.NativeUtils), BFNativeUtilsWrap.__Register); @@ -1424,16 +1430,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(BF.SoundManager), BFSoundManagerWrap.__Register); + } + + static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(BF.Task), BFTaskWrap.__Register); translator.DelayWrapLoader(typeof(BF.Delayed), BFDelayedWrap.__Register); - } - - static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(BF.TaskManager), BFTaskManagerWrap.__Register); @@ -1581,16 +1587,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(BF.BFLayoutBase), BFBFLayoutBaseWrap.__Register); + } + + static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(BF.BFCell), BFBFCellWrap.__Register); translator.DelayWrapLoader(typeof(BF.BFScrollRectBase), BFBFScrollRectBaseWrap.__Register); - } - - static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(BF.BFScrollRectCommon), BFBFScrollRectCommonWrap.__Register); @@ -1738,16 +1744,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(TMPro.TMP_MaterialReference), TMProTMP_MaterialReferenceWrap.__Register); + } + + static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(TMPro.MaterialReference), TMProMaterialReferenceWrap.__Register); translator.DelayWrapLoader(typeof(TMPro.TMP_Asset), TMProTMP_AssetWrap.__Register); - } - - static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(TMPro.TMP_Character), TMProTMP_CharacterWrap.__Register); @@ -1895,16 +1901,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(TMPro.TMP_TextParsingUtilities), TMProTMP_TextParsingUtilitiesWrap.__Register); + } + + static void wrapInit12(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(TMPro.CaretInfo), TMProCaretInfoWrap.__Register); translator.DelayWrapLoader(typeof(TMPro.TMP_TextUtilities), TMProTMP_TextUtilitiesWrap.__Register); - } - - static void wrapInit12(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(TMPro.TMP_UpdateManager), TMProTMP_UpdateManagerWrap.__Register); @@ -2052,16 +2058,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(UnityEngine.UI.LayoutUtility), UnityEngineUILayoutUtilityWrap.__Register); + } + + static void wrapInit13(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(UnityEngine.UI.VerticalLayoutGroup), UnityEngineUIVerticalLayoutGroupWrap.__Register); translator.DelayWrapLoader(typeof(UnityEngine.UI.Mask), UnityEngineUIMaskWrap.__Register); - } - - static void wrapInit13(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(UnityEngine.UI.MaskUtilities), UnityEngineUIMaskUtilitiesWrap.__Register); @@ -2209,16 +2215,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(DG.Tweening.Core.DOTweenSettings.ModulesSetup), DGTweeningCoreDOTweenSettingsModulesSetupWrap.__Register); + } + + static void wrapInit14(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(CloudControl), CloudControlWrap.__Register); translator.DelayWrapLoader(typeof(AFInAppEventParameterName), AFInAppEventParameterNameWrap.__Register); - } - - static void wrapInit14(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(AFInAppEventType), AFInAppEventTypeWrap.__Register); @@ -2271,9 +2277,6 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(MonkeyPost), MonkeyPostWrap.__Register); - translator.DelayWrapLoader(typeof(AFAdRevenueEvent), AFAdRevenueEventWrap.__Register); - - translator.DelayWrapLoader(typeof(UIInputHelper), UIInputHelperWrap.__Register); @@ -2369,14 +2372,14 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(IronSourceConfig), IronSourceConfigWrap.__Register); - - translator.DelayWrapLoader(typeof(IronSourceConstants), IronSourceConstantsWrap.__Register); - } static void wrapInit15(LuaEnv luaenv, ObjectTranslator translator) { + translator.DelayWrapLoader(typeof(IronSourceConstants), IronSourceConstantsWrap.__Register); + + translator.DelayWrapLoader(typeof(IronSourceError), IronSourceErrorWrap.__Register); @@ -2431,6 +2434,66 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(UnsupportedPlatformAgent), UnsupportedPlatformAgentWrap.__Register); + translator.DelayWrapLoader(typeof(ISAdQualityDeviceIdType), ISAdQualityDeviceIdTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityAdType), ISAdQualityAdTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityConfig), ISAdQualityConfigWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityCustomMediationRevenue), ISAdQualityCustomMediationRevenueWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityInitCallback), ISAdQualityInitCallbackWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityInitCallbackWrapper), ISAdQualityInitCallbackWrapperWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityInitError), ISAdQualityInitErrorWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityLogLevel), ISAdQualityLogLevelWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityMediationNetwork), ISAdQualityMediationNetworkWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualitySegment), ISAdQualitySegmentWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityUtils), ISAdQualityUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceAdQuality), IronSourceAdQualityWrap.__Register); + + + translator.DelayWrapLoader(typeof(ISAdQualityEditorScript), ISAdQualityEditorScriptWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceAdQualityManifestTools), IronSourceAdQualityManifestToolsWrap.__Register); + + + translator.DelayWrapLoader(typeof(ObjectKvp), ObjectKvpWrap.__Register); + + + translator.DelayWrapLoader(typeof(ObjectDictionary), ObjectDictionaryWrap.__Register); + + + translator.DelayWrapLoader(typeof(BaseBehaviour), BaseBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(CodeGeneratedSingleton), CodeGeneratedSingletonWrap.__Register); + + + translator.DelayWrapLoader(typeof(SceneSingleton), SceneSingletonWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnitySingleton), UnitySingletonWrap.__Register); + + translator.DelayWrapLoader(typeof(TAExample), TAExampleWrap.__Register); @@ -2466,6 +2529,10 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper), ThinkingAnalyticsWrapperThinkingAnalyticsWrapperWrap.__Register); + } + + static void wrapInit16(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(ThinkingAnalytics.Utils.TD_Log), ThinkingAnalyticsUtilsTD_LogWrap.__Register); @@ -2479,10 +2546,16 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler), ThinkingAnalyticsTaExceptionThinkingSDKExceptionHandlerWrap.__Register); + translator.DelayWrapLoader(typeof(ISAdQualityJSON.Json), ISAdQualityJSONJsonWrap.__Register); + + translator.DelayWrapLoader(typeof(IronSourceJSON.Json), IronSourceJSONJsonWrap.__Register); - translator.DelayWrapLoader(typeof(AppsFlyerSDK.AppsFlyerAdRevenue), AppsFlyerSDKAppsFlyerAdRevenueWrap.__Register); + translator.DelayWrapLoader(typeof(MolocoSdk.MolocoSDK), MolocoSdkMolocoSDKWrap.__Register); + + + translator.DelayWrapLoader(typeof(MolocoSdk.PrivacySettings), MolocoSdkPrivacySettingsWrap.__Register); translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONNode), comadjustsdkJSONNodeWrap.__Register); @@ -2529,10 +2602,6 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustLogLevelExtension), comadjustsdkAdjustLogLevelExtensionWrap.__Register); - } - - static void wrapInit16(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustPlayStoreSubscription), comadjustsdkAdjustPlayStoreSubscriptionWrap.__Register); @@ -2617,6 +2686,10 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(System.DateTime), SystemDateTimeWrap.__Register); + } + + static void wrapInit17(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(System.DateTimeOffset), SystemDateTimeOffsetWrap.__Register); @@ -2686,10 +2759,6 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(UnityEngine.Camera.RenderRequestOutputSpace), UnityEngineCameraRenderRequestOutputSpaceWrap.__Register); - } - - static void wrapInit17(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(UnityEngine.TextCore.FaceInfo), UnityEngineTextCoreFaceInfoWrap.__Register); @@ -2774,6 +2843,10 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(UnityEngine.Camera.GateFitMode), UnityEngineCameraGateFitModeWrap.__Register); + } + + static void wrapInit18(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(UnityEngine.Camera.StereoscopicEye), UnityEngineCameraStereoscopicEyeWrap.__Register); @@ -2843,10 +2916,6 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.MovementType), UnityEngineUIScrollRectMovementTypeWrap.__Register); - } - - static void wrapInit18(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), UnityEngineUIScrollRectScrollbarVisibilityWrap.__Register); @@ -2931,6 +3000,10 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(TMPro.TextAlignmentOptions), TMProTextAlignmentOptionsWrap.__Register); + } + + static void wrapInit19(LuaEnv luaenv, ObjectTranslator translator) + { translator.DelayWrapLoader(typeof(TMPro.TextMeshProUGUI), TMProTextMeshProUGUIWrap.__Register); @@ -3000,10 +3073,6 @@ namespace XLua.CSObjectWrap translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), ThinkingAnalyticsThinkingAnalyticsAPITATimeZoneWrap.__Register); - } - - static void wrapInit19(LuaEnv luaenv, ObjectTranslator translator) - { translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), ThinkingAnalyticsThinkingAnalyticsAPITAModeWrap.__Register); diff --git a/Assets/XLua/Gen/link.xml b/Assets/XLua/Gen/link.xml index 07cb23734..8ed4e4c91 100644 --- a/Assets/XLua/Gen/link.xml +++ b/Assets/XLua/Gen/link.xml @@ -70,6 +70,8 @@ + + @@ -201,7 +203,6 @@ - @@ -253,6 +254,26 @@ + + + + + + + + + + + + + + + + + + + + @@ -269,8 +290,10 @@ + - + +